package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleDetailReq;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;

import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleListReq;
import java.util.ArrayList;

import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.biz.service.TargetCycleService;
import com.wicket.okrapp.base.service.MOmsEvaObjTargetCycleWeightSetService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaObjTargetCycleWeightSet;
import com.wicket.okrapp.base.service.dto.req.BatchQueryEvaObjTargetCycleWeightReq;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrapp.biz.service.ExecuteProgressService;
import com.wicket.okrapp.biz.service.dto.common.EvaObjTargetCycleWeightDto;
import com.wicket.okrapp.biz.service.nb.NbWeightTarget;
import com.wicket.okrapp.biz.service.TargetContentService;
import com.wicket.okrapp.base.service.MOmsVirtualOrgMemberDeptService;
import com.wicket.okrapp.dal.po.mbg.OmsVirtualOrgMemberDept;
import com.wicket.okrapp.base.service.dto.req.QueryVirtualOrgMemberDeptListReq;
import com.wicket.okrapp.base.service.MOmsTargetObjectiveService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetObjective;
import com.wicket.okrapp.base.service.dto.req.BatchQueryTargetObjListReq;
import com.wicket.okrapp.biz.service.ProgressPublicTechnicaCapacityService;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleWeightDetailReq;
import com.wicket.okrapp.base.service.dto.req.BatchQueryEvaObjTargetCycleWeightListReq;
import com.wicket.okrcalc.integration.dto.CalculateCalcServiceCollectionComRespDto;
import com.wicket.okrcalc.integration.dto.CalculateCalcServiceCollectionComReqDto;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrcalc.integration.FwCalcCalculationRulesClient;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrapp.base.service.MOmsExecuteProgressService;
import com.wicket.okrapp.base.service.dto.req.QueryTargetCycleCodeOrderStoMaxListReq;
import com.wicket.okrapp.base.service.MOmsEvaBatchRelatedSetService;
import com.wicket.okrapp.base.service.MOmsTaskService;
import com.wicket.okrapp.biz.service.TargetContComService;
import com.wicket.okrapp.base.service.MOmsTargetAttributionCycleService;
import com.wicket.okrapp.base.service.dto.req.BatchQueryEvaObjTargetCycleReq;
import com.wicket.okrapp.biz.service.TargetCalcService;
import com.wicket.okrapp.biz.service.DashboardTargetContentService;
import com.wicket.okrapp.base.service.MOmsVirtualOrgMemberService;
import com.wicket.okrapp.dal.po.mbg.OmsVirtualOrgMember;
import com.wicket.okrapp.base.service.dto.req.BatchQueryVirtualOrgMemberReq;
import com.wicket.okrapp.base.service.dto.req.BatchQueryVirtualOrgMemberDeptReq;
/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class WeightTargetServiceImpl
  implements com.wicket.okrapp.biz.service.WeightTargetService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
//@Resource
 //private undefinedService undefinedService;
@Resource
  private TargetCycleService targetCycleService;
@Resource
  private MOmsEvaObjTargetCycleWeightSetService mOmsEvaObjTargetCycleWeightSetService;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  private ExecuteProgressService executeProgressService;
@Resource
  private NbWeightTarget nbWeightTarget;
@Resource
  private TargetContentService targetContentService;
@Resource
  private MOmsVirtualOrgMemberDeptService mOmsVirtualOrgMemberDeptService;
@Resource
  private MOmsTargetObjectiveService mOmsTargetObjectiveService;
@Resource
  private ProgressPublicTechnicaCapacityService progressPublicTechnicaCapacityService;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private FwCalcCalculationRulesClient fwCalcCalculationRulesClient;
@Resource
  private MOmsExecuteProgressService mOmsExecuteProgressService;
@Resource
  private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
@Resource
  private MOmsTaskService mOmsTaskService;
@Resource
  private TargetContComService targetContComService;
@Resource
  private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
@Resource
  private TargetCalcService targetCalcService;
@Resource
  private DashboardTargetContentService dashboardTargetContentService;
@Resource
  private MOmsVirtualOrgMemberService mOmsVirtualOrgMemberService;
/**
   * D3批量增树叶子权重设置(公共)[7150]
   * gen by moon at 6/9/2024, 1:08:01 AM
   */
  @Trace(operationName = "D3批量增树叶子权重设置(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchAddTreeLeafWeightSetComRespDto batchAddTreeLeafWeightSetCom(BatchAddTreeLeafWeightSetComReqDto reqDto){
    
      
      //virtualUsage 3-3-09查当前叶子目标周期列表  44565
      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1018871_1_44565
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1018856_1_44565
queryEvaObjTargetCycleListReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018858_1_44565
queryEvaObjTargetCycleListReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1020910_1_44565
queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1018870_1_44565
queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018865_1_44565
    }
  
    /*3-3-09查当前叶子目标周期列表[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjEntityId(),"D3批量增树叶子权重设置(公共)-3-3-09查当前叶子目标周期列表-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTypeCode(),"D3批量增树叶子权重设置(公共)-3-3-09查当前叶子目标周期列表-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(),"D3批量增树叶子权重设置(公共)-3-3-09查当前叶子目标周期列表-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-3-3-09查当前叶子目标周期列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3批量增树叶子权重设置(公共)-3-3-09查当前叶子目标周期列表-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
if((reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("SINGLE_CYCLE")||reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("IRREGULAR_CYCLE"))) {
        //if((D3批量增树叶子权重设置(公共).周期模式 等于 单周期 or D3批量增树叶子权重设置(公共).周期模式 等于 不规则周期))  44563
        
//ModelCode: circulationCollections
        for (OmsEvaluationObjectTargetCycle circulationCollectionsRes: listOmsEvaluationObjectTargetCycle){ 
      
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1018904_1_44568
addTargetContCycleWeightComReqDto.setIsRedundantMidCycle("FALSE");//sourceId:1018905_1_44568
if(circulationCollectionsRes!=null){
      addTargetContCycleWeightComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018902_1_44568
addTargetContCycleWeightComReqDto.setWeightObjTypeCode(circulationCollectionsRes.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018903_1_44568
addTargetContCycleWeightComReqDto.setOrderNumber(circulationCollectionsRes.getOrderNumber());//SimpleFieldAssign//sourceId:1018910_1_44568
addTargetContCycleWeightComReqDto.setRelativeOrderNumber(circulationCollectionsRes.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018909_1_44568
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021975_1_44568
addTargetContCycleWeightComReqDto.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021976_1_44568
      addTargetContCycleWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018906_1_44568
addTargetContCycleWeightComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018907_1_44568
    }
  
    /*D3-增目标内容目标周期权重(父周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto)/*vcase invoke isSameApp*/;
      
      
      
//ModelCode: circulationEnd
        }
      
      }
else if((reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("FATHER_SON_CYCLE"))){
       //elseif(D3批量增树叶子权重设置(公共).周期模式 等于 父子周期)  44569
      
//ModelCode: circulationCollections
        for (OmsEvaluationObjectTargetCycle circulationCollectionsRes_2: listOmsEvaluationObjectTargetCycle){ 
      
if((circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsParentCycle() !=null && circulationCollectionsRes_2.getIsParentCycle().equals("TRUE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsSubCycle() !=null && circulationCollectionsRes_2.getIsSubCycle().equals("FALSE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsMetaphase() !=null && circulationCollectionsRes_2.getIsMetaphase().equals("FALSE"))) {
        //if((M3当前叶子目标周期发牌【循环开始】.是否父周期 等于 是 and M3当前叶子目标周期发牌【循环开始】.是否子周期 等于 否 and M3当前叶子目标周期发牌【循环开始】.是否中期 等于 否))  44573
        
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_2 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_1=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_1.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1018904_1_44574
addTargetContCycleWeightComReqDto_1.setIsRedundantMidCycle("FALSE");//sourceId:1018905_1_44574
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_1.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018902_1_44574
addTargetContCycleWeightComReqDto_1.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018903_1_44574
addTargetContCycleWeightComReqDto_1.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018910_1_44574
addTargetContCycleWeightComReqDto_1.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018909_1_44574
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_1.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021975_1_44574
addTargetContCycleWeightComReqDto_1.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021976_1_44574
      addTargetContCycleWeightComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018906_1_44574
addTargetContCycleWeightComReqDto_1.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018907_1_44574
    }
  
    /*D3-增目标内容目标周期权重(父周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_1.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_2 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_1)/*vcase invoke isSameApp*/;
      
      
      
      }
else if((circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsSubCycle() !=null && circulationCollectionsRes_2.getIsSubCycle().equals("TRUE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsParentCycle() !=null && circulationCollectionsRes_2.getIsParentCycle().equals("FALSE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsMetaphase() !=null && circulationCollectionsRes_2.getIsMetaphase().equals("FALSE"))){
       //elseif((M3当前叶子目标周期发牌【循环开始】.是否子周期 等于 是 and M3当前叶子目标周期发牌【循环开始】.是否父周期 等于 否 and M3当前叶子目标周期发牌【循环开始】.是否中期 等于 否))  44575
      
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_3 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_2=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_2.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1018919_1_44576
addTargetContCycleWeightComReqDto_2.setIsRedundantMidCycle("FALSE");//sourceId:1018920_1_44576
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_2.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018917_1_44576
addTargetContCycleWeightComReqDto_2.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018918_1_44576
addTargetContCycleWeightComReqDto_2.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018925_1_44576
addTargetContCycleWeightComReqDto_2.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018924_1_44576
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_2.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021977_1_44576
addTargetContCycleWeightComReqDto_2.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021978_1_44576
      addTargetContCycleWeightComReqDto_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018921_1_44576
addTargetContCycleWeightComReqDto_2.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018922_1_44576
    }
  
    /*D3-新增目标内容目标周期权重(子周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_2.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_3 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_2)/*vcase invoke isSameApp*/;
      
      
      
    }
else if((circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsMetaphase() !=null && circulationCollectionsRes_2.getIsMetaphase().equals("TRUE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsParentCycle() !=null && circulationCollectionsRes_2.getIsParentCycle().equals("FALSE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsSubCycle() !=null && circulationCollectionsRes_2.getIsSubCycle().equals("FALSE"))){
       //elseif((M3当前叶子目标周期发牌【循环开始】.是否中期 等于 是 and M3当前叶子目标周期发牌【循环开始】.是否父周期 等于 否 and M3当前叶子目标周期发牌【循环开始】.是否子周期 等于 否))  44577
      
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_5 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_3=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_3.setParentSubMidCycleType("MID_CYCLE");//sourceId:1018928_1_44578
addTargetContCycleWeightComReqDto_3.setIsRedundantMidCycle("FALSE");//sourceId:1018929_1_44578
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_3.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018926_1_44578
addTargetContCycleWeightComReqDto_3.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018927_1_44578
addTargetContCycleWeightComReqDto_3.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018934_1_44578
addTargetContCycleWeightComReqDto_3.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018933_1_44578
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_3.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021979_1_44578
addTargetContCycleWeightComReqDto_3.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021980_1_44578
      addTargetContCycleWeightComReqDto_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018930_1_44578
addTargetContCycleWeightComReqDto_3.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018931_1_44578
    }
  
    /*D3-新增目标内容目标周期权重(中期：非冗余中期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_3.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_5 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_3)/*vcase invoke isSameApp*/;
      
      
      
    }
else if((circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsParentCycle() !=null && circulationCollectionsRes_2.getIsParentCycle().equals("TRUE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsSubCycle() !=null && circulationCollectionsRes_2.getIsSubCycle().equals("TRUE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsMetaphase() !=null && circulationCollectionsRes_2.getIsMetaphase().equals("TRUE"))){
       //elseif((M3当前叶子目标周期发牌【循环开始】.是否父周期 等于 是 and M3当前叶子目标周期发牌【循环开始】.是否子周期 等于 是 and M3当前叶子目标周期发牌【循环开始】.是否中期 等于 是))  44579
      
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_7 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_4=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_4.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1018904_1_44580
addTargetContCycleWeightComReqDto_4.setIsRedundantMidCycle("FALSE");//sourceId:1018905_1_44580
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_4.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018902_1_44580
addTargetContCycleWeightComReqDto_4.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018903_1_44580
addTargetContCycleWeightComReqDto_4.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018910_1_44580
addTargetContCycleWeightComReqDto_4.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018909_1_44580
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_4.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021975_1_44580
addTargetContCycleWeightComReqDto_4.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021976_1_44580
      addTargetContCycleWeightComReqDto_4.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018906_1_44580
addTargetContCycleWeightComReqDto_4.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018907_1_44580
    }
  
    /*D3-增目标内容目标周期权重(父周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_4.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_7 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_4)/*vcase invoke isSameApp*/;
      
      
      
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_8 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_5=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_5.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1018919_1_44581
addTargetContCycleWeightComReqDto_5.setIsRedundantMidCycle("FALSE");//sourceId:1018920_1_44581
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_5.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018917_1_44581
addTargetContCycleWeightComReqDto_5.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018918_1_44581
addTargetContCycleWeightComReqDto_5.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018925_1_44581
addTargetContCycleWeightComReqDto_5.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018924_1_44581
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_5.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021977_1_44581
addTargetContCycleWeightComReqDto_5.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021978_1_44581
      addTargetContCycleWeightComReqDto_5.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018921_1_44581
addTargetContCycleWeightComReqDto_5.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018922_1_44581
    }
  
    /*D3-新增目标内容目标周期权重(子周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_5.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_8 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_5)/*vcase invoke isSameApp*/;
      
      
      
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_9 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_6=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_6.setParentSubMidCycleType("MID_CYCLE");//sourceId:1018937_1_44582
addTargetContCycleWeightComReqDto_6.setIsRedundantMidCycle("TRUE");//sourceId:1018938_1_44582
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_6.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018935_1_44582
addTargetContCycleWeightComReqDto_6.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018936_1_44582
addTargetContCycleWeightComReqDto_6.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018943_1_44582
addTargetContCycleWeightComReqDto_6.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018942_1_44582
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_6.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021981_1_44582
addTargetContCycleWeightComReqDto_6.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021982_1_44582
      addTargetContCycleWeightComReqDto_6.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018939_1_44582
addTargetContCycleWeightComReqDto_6.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018940_1_44582
    }
  
    /*D3-新增目标内容目标周期权重(中期：冗余中期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_6.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_9 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_6)/*vcase invoke isSameApp*/;
      
      
      
    }
else if((circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsParentCycle() !=null && circulationCollectionsRes_2.getIsParentCycle().equals("TRUE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsMetaphase() !=null && circulationCollectionsRes_2.getIsMetaphase().equals("TRUE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsSubCycle() !=null && circulationCollectionsRes_2.getIsSubCycle().equals("FALSE"))){
       //elseif((M3当前叶子目标周期发牌【循环开始】.是否父周期 等于 是 and M3当前叶子目标周期发牌【循环开始】.是否中期 等于 是 and M3当前叶子目标周期发牌【循环开始】.是否子周期 等于 否))  44583
      
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_11 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_7=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_7.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1018904_1_44584
addTargetContCycleWeightComReqDto_7.setIsRedundantMidCycle("FALSE");//sourceId:1018905_1_44584
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_7.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018902_1_44584
addTargetContCycleWeightComReqDto_7.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018903_1_44584
addTargetContCycleWeightComReqDto_7.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018910_1_44584
addTargetContCycleWeightComReqDto_7.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018909_1_44584
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_7.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021975_1_44584
addTargetContCycleWeightComReqDto_7.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021976_1_44584
      addTargetContCycleWeightComReqDto_7.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018906_1_44584
addTargetContCycleWeightComReqDto_7.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018907_1_44584
    }
  
    /*D3-增目标内容目标周期权重(父周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_7.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_11 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_7)/*vcase invoke isSameApp*/;
      
      
      
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_12 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_8=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_8.setParentSubMidCycleType("MID_CYCLE");//sourceId:1018937_1_44585
addTargetContCycleWeightComReqDto_8.setIsRedundantMidCycle("TRUE");//sourceId:1018938_1_44585
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_8.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018935_1_44585
addTargetContCycleWeightComReqDto_8.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018936_1_44585
addTargetContCycleWeightComReqDto_8.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018943_1_44585
addTargetContCycleWeightComReqDto_8.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018942_1_44585
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_8.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018939_1_44585
addTargetContCycleWeightComReqDto_8.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018940_1_44585
    }
  
    /*D3-新增目标内容目标周期权重(中期：冗余中期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_8.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_12 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_8)/*vcase invoke isSameApp*/;
      
      
      
    }
else if((circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsParentCycle() !=null && circulationCollectionsRes_2.getIsParentCycle().equals("TRUE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsSubCycle() !=null && circulationCollectionsRes_2.getIsSubCycle().equals("TRUE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsMetaphase() !=null && circulationCollectionsRes_2.getIsMetaphase().equals("FALSE"))){
       //elseif((M3当前叶子目标周期发牌【循环开始】.是否父周期 等于 是 and M3当前叶子目标周期发牌【循环开始】.是否子周期 等于 是 and M3当前叶子目标周期发牌【循环开始】.是否中期 等于 否))  44586
      
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_13 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_9=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_9.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1018904_1_44587
addTargetContCycleWeightComReqDto_9.setIsRedundantMidCycle("FALSE");//sourceId:1018905_1_44587
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_9.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018902_1_44587
addTargetContCycleWeightComReqDto_9.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018903_1_44587
addTargetContCycleWeightComReqDto_9.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018910_1_44587
addTargetContCycleWeightComReqDto_9.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018909_1_44587
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_9.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021975_1_44587
addTargetContCycleWeightComReqDto_9.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021976_1_44587
      addTargetContCycleWeightComReqDto_9.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018906_1_44587
addTargetContCycleWeightComReqDto_9.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018907_1_44587
    }
  
    /*D3-增目标内容目标周期权重(父周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_9.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-增目标内容目标周期权重(父周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_13 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_9)/*vcase invoke isSameApp*/;
      
      
      
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_14 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_10=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_10.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1018919_1_44588
addTargetContCycleWeightComReqDto_10.setIsRedundantMidCycle("FALSE");//sourceId:1018920_1_44588
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_10.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018917_1_44588
addTargetContCycleWeightComReqDto_10.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018918_1_44588
addTargetContCycleWeightComReqDto_10.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018925_1_44588
addTargetContCycleWeightComReqDto_10.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018924_1_44588
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_10.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021977_1_44588
addTargetContCycleWeightComReqDto_10.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021978_1_44588
      addTargetContCycleWeightComReqDto_10.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018921_1_44588
addTargetContCycleWeightComReqDto_10.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018922_1_44588
    }
  
    /*D3-新增目标内容目标周期权重(子周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_10.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_14 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_10)/*vcase invoke isSameApp*/;
      
      
      
    }
else if((circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsSubCycle() !=null && circulationCollectionsRes_2.getIsSubCycle().equals("TRUE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsMetaphase() !=null && circulationCollectionsRes_2.getIsMetaphase().equals("TRUE")&&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2.getIsParentCycle() !=null && circulationCollectionsRes_2.getIsParentCycle().equals("FALSE"))){
       //elseif((M3当前叶子目标周期发牌【循环开始】.是否子周期 等于 是 and M3当前叶子目标周期发牌【循环开始】.是否中期 等于 是 and M3当前叶子目标周期发牌【循环开始】.是否父周期 等于 否))  69798

AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_15 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_11=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_11.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1018919_1_69799
addTargetContCycleWeightComReqDto_11.setIsRedundantMidCycle("FALSE");//sourceId:1018920_1_69799
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_11.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018917_1_69799
addTargetContCycleWeightComReqDto_11.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018918_1_69799
addTargetContCycleWeightComReqDto_11.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018925_1_69799
addTargetContCycleWeightComReqDto_11.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018924_1_69799
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_11.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021977_1_69799
addTargetContCycleWeightComReqDto_11.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021978_1_69799
addTargetContCycleWeightComReqDto_11.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018921_1_69799
addTargetContCycleWeightComReqDto_11.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018922_1_69799
    }

    /*D3-新增目标内容目标周期权重(子周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_11.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_15 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_11)/*vcase invoke isSameApp*/;



AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_16 = null;
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_12=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_12.setParentSubMidCycleType("MID_CYCLE");//sourceId:1018937_1_69800
addTargetContCycleWeightComReqDto_12.setIsRedundantMidCycle("TRUE");//sourceId:1018938_1_69800
if(circulationCollectionsRes_2!=null){
      addTargetContCycleWeightComReqDto_12.setEvaObjTargetCycleId(circulationCollectionsRes_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1018935_1_69800
addTargetContCycleWeightComReqDto_12.setWeightObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1018936_1_69800
addTargetContCycleWeightComReqDto_12.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:1018943_1_69800
addTargetContCycleWeightComReqDto_12.setRelativeOrderNumber(circulationCollectionsRes_2.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1018942_1_69800
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_12.setWeightValue(reqDto.getWeightValue());//SimpleFieldAssign//sourceId:1021981_1_69800
addTargetContCycleWeightComReqDto_12.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1021982_1_69800
addTargetContCycleWeightComReqDto_12.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1018939_1_69800
addTargetContCycleWeightComReqDto_12.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1018940_1_69800
    }

    /*D3-新增目标内容目标周期权重(中期：冗余中期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_12.getEvaObjTargetCycleId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getWeightObjTypeCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getParentSubMidCycleType(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getIsRedundantMidCycle(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getRelativeOrderNumber(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getEvaluationTemplateId(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getBatchCode(),"D3批量增树叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_16 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_12)/*vcase invoke isSameApp*/;



    }
//ModelCode: circulationEnd
        }
      
    }
BatchAddTreeLeafWeightSetComRespDto retData = new BatchAddTreeLeafWeightSetComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3增树单叶子权重设置(公共)[7155]
   * gen by moon at 6/9/2024, 1:08:05 AM
   */
  @Trace(operationName = "D3增树单叶子权重设置(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddTreeSingleLeafWeightSetComRespDto addTreeSingleLeafWeightSetCom(AddTreeSingleLeafWeightSetComReqDto reqDto){


      //virtualUsage 3-3-09查当前树叶子目标周期详情  44631
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1020679_1_44631
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020677_1_44631
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020678_1_44631
    }

    /*3-3-09查当前树叶子目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-3-3-09查当前树叶子目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-3-3-09查当前树叶子目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3增树单叶子权重设置(公共)-3-3-09查当前树叶子目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("SINGLE_CYCLE")||reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("IRREGULAR_CYCLE"))) {
        //if((D3增树单叶子权重设置(公共).周期模式 等于 单周期 or D3增树单叶子权重设置(公共).周期模式 等于 不规则周期))  44630

AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1020587_1_44632
addTargetContCycleWeightComReqDto.setIsRedundantMidCycle("FALSE");//sourceId:1020588_1_44632
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020585_1_44632
addTargetContCycleWeightComReqDto.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020586_1_44632
addTargetContCycleWeightComReqDto.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020593_1_44632
addTargetContCycleWeightComReqDto.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020592_1_44632
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020589_1_44632
addTargetContCycleWeightComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020590_1_44632
    }

    /*D3-新增目标内容目标周期权重(父周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto)/*vcase invoke isSameApp*/;



           }
      }
else if((reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("FATHER_SON_CYCLE"))){
       //elseif(D3增树单叶子权重设置(公共).周期模式 等于 父子周期)  44633

if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("FALSE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("FALSE"))) {
        //if((3-3-09查当前树叶子目标周期详情.是否父周期 等于 是 and 3-3-09查当前树叶子目标周期详情.是否子周期 等于 否 and 3-3-09查当前树叶子目标周期详情.是否中期 等于 否))  44636

AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_2 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_1=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_1.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1020587_1_44637
addTargetContCycleWeightComReqDto_1.setIsRedundantMidCycle("FALSE");//sourceId:1020588_1_44637
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020585_1_44637
addTargetContCycleWeightComReqDto_1.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020586_1_44637
addTargetContCycleWeightComReqDto_1.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020593_1_44637
addTargetContCycleWeightComReqDto_1.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020592_1_44637
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020589_1_44637
addTargetContCycleWeightComReqDto_1.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020590_1_44637
    }

    /*D3-新增目标内容目标周期权重(父周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_1.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_1.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_2 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_1)/*vcase invoke isSameApp*/;



           }
      }
else if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("FALSE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("FALSE"))){
       //elseif((3-3-09查当前树叶子目标周期详情.是否中期 等于 是 and 3-3-09查当前树叶子目标周期详情.是否父周期 等于 否 and 3-3-09查当前树叶子目标周期详情.是否子周期 等于 否))  44638

AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_3 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_2=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_2.setParentSubMidCycleType("MID_CYCLE");//sourceId:1020683_1_44639
addTargetContCycleWeightComReqDto_2.setIsRedundantMidCycle("FALSE");//sourceId:1020684_1_44639
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_2.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020681_1_44639
addTargetContCycleWeightComReqDto_2.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020682_1_44639
addTargetContCycleWeightComReqDto_2.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020689_1_44639
addTargetContCycleWeightComReqDto_2.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020688_1_44639
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020685_1_44639
addTargetContCycleWeightComReqDto_2.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020686_1_44639
    }

    /*D3-新增目标内容目标周期权重(中期：非冗余中期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_2.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_2.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：非冗余中期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_3 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_2)/*vcase invoke isSameApp*/;



           }
    }
else if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("FALSE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("FALSE"))){
       //elseif((3-3-09查当前树叶子目标周期详情.是否子周期 等于 是 and 3-3-09查当前树叶子目标周期详情.是否父周期 等于 否 and 3-3-09查当前树叶子目标周期详情.是否中期 等于 否))  44640

AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_5 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_3=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_3.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1020692_1_44641
addTargetContCycleWeightComReqDto_3.setIsRedundantMidCycle("FALSE");//sourceId:1020693_1_44641
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_3.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020690_1_44641
addTargetContCycleWeightComReqDto_3.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020691_1_44641
addTargetContCycleWeightComReqDto_3.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020698_1_44641
addTargetContCycleWeightComReqDto_3.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020697_1_44641
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020694_1_44641
addTargetContCycleWeightComReqDto_3.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020695_1_44641
    }

    /*D3-新增目标内容目标周期权重(子周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_3.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_3.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_5 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_3)/*vcase invoke isSameApp*/;



           }
    }
else if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("FALSE"))){
       //elseif((3-3-09查当前树叶子目标周期详情.是否父周期 等于 是 and 3-3-09查当前树叶子目标周期详情.是否子周期 等于 是 and 3-3-09查当前树叶子目标周期详情.是否中期 等于 否))  44642

AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_7 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_4=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_4.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1020587_1_44643
addTargetContCycleWeightComReqDto_4.setIsRedundantMidCycle("FALSE");//sourceId:1020588_1_44643
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_4.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020585_1_44643
addTargetContCycleWeightComReqDto_4.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020586_1_44643
addTargetContCycleWeightComReqDto_4.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020593_1_44643
addTargetContCycleWeightComReqDto_4.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020592_1_44643
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_4.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020589_1_44643
addTargetContCycleWeightComReqDto_4.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020590_1_44643
    }

    /*D3-新增目标内容目标周期权重(父周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_4.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_4.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_7 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_4)/*vcase invoke isSameApp*/;



           }
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_8 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_5=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_5.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1020692_1_44644
addTargetContCycleWeightComReqDto_5.setIsRedundantMidCycle("FALSE");//sourceId:1020693_1_44644
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_5.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020690_1_44644
addTargetContCycleWeightComReqDto_5.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020691_1_44644
addTargetContCycleWeightComReqDto_5.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020698_1_44644
addTargetContCycleWeightComReqDto_5.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020697_1_44644
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_5.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020694_1_44644
addTargetContCycleWeightComReqDto_5.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020695_1_44644
    }

    /*D3-新增目标内容目标周期权重(子周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_5.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_5.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_8 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_5)/*vcase invoke isSameApp*/;



           }
    }
else if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("FALSE"))){
       //elseif((3-3-09查当前树叶子目标周期详情.是否父周期 等于 是 and 3-3-09查当前树叶子目标周期详情.是否中期 等于 是 and 3-3-09查当前树叶子目标周期详情.是否子周期 等于 否))  44645

AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_9 = null;
    if(omsEvaluationObjectTargetCycle !=null){
    AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_6=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_6.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1020587_1_44646
addTargetContCycleWeightComReqDto_6.setIsRedundantMidCycle("FALSE");//sourceId:1020588_1_44646
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_6.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020585_1_44646
addTargetContCycleWeightComReqDto_6.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020586_1_44646
addTargetContCycleWeightComReqDto_6.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020593_1_44646
addTargetContCycleWeightComReqDto_6.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020592_1_44646
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_6.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020589_1_44646
addTargetContCycleWeightComReqDto_6.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020590_1_44646
    }

    /*D3-新增目标内容目标周期权重(父周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_6.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_6.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_9 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_6)/*vcase invoke isSameApp*/;



           }
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_10 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_7=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_7.setParentSubMidCycleType("MID_CYCLE");//sourceId:1020701_1_44647
addTargetContCycleWeightComReqDto_7.setIsRedundantMidCycle("TRUE");//sourceId:1020702_1_44647
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_7.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020699_1_44647
addTargetContCycleWeightComReqDto_7.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020700_1_44647
addTargetContCycleWeightComReqDto_7.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020707_1_44647
addTargetContCycleWeightComReqDto_7.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020706_1_44647
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_7.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020703_1_44647
addTargetContCycleWeightComReqDto_7.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020704_1_44647
    }

    /*D3-新增目标内容目标周期权重(中期：冗余中期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_7.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_7.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_10 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_7)/*vcase invoke isSameApp*/;



           }
    }
else if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("TRUE"))){
       //elseif((3-3-09查当前树叶子目标周期详情.是否父周期 等于 是 and 3-3-09查当前树叶子目标周期详情.是否中期 等于 是 and 3-3-09查当前树叶子目标周期详情.是否子周期 等于 是))  44648

AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_12 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_8=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_8.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1020587_1_44649
addTargetContCycleWeightComReqDto_8.setIsRedundantMidCycle("FALSE");//sourceId:1020588_1_44649
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_8.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020585_1_44649
addTargetContCycleWeightComReqDto_8.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020586_1_44649
addTargetContCycleWeightComReqDto_8.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020593_1_44649
addTargetContCycleWeightComReqDto_8.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020592_1_44649
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_8.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020589_1_44649
addTargetContCycleWeightComReqDto_8.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020590_1_44649
    }

    /*D3-新增目标内容目标周期权重(父周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_8.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_8.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(父周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_12 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_8)/*vcase invoke isSameApp*/;



           }
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_13 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_9=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_9.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1020692_1_44650
addTargetContCycleWeightComReqDto_9.setIsRedundantMidCycle("FALSE");//sourceId:1020693_1_44650
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_9.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020690_1_44650
addTargetContCycleWeightComReqDto_9.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020691_1_44650
addTargetContCycleWeightComReqDto_9.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020698_1_44650
addTargetContCycleWeightComReqDto_9.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020697_1_44650
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_9.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020694_1_44650
addTargetContCycleWeightComReqDto_9.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020695_1_44650
    }

    /*D3-新增目标内容目标周期权重(子周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_9.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_9.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_13 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_9)/*vcase invoke isSameApp*/;



           }
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_14 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_10=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_10.setParentSubMidCycleType("MID_CYCLE");//sourceId:1020701_1_44651
addTargetContCycleWeightComReqDto_10.setIsRedundantMidCycle("TRUE");//sourceId:1020702_1_44651
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_10.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020699_1_44651
addTargetContCycleWeightComReqDto_10.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020700_1_44651
addTargetContCycleWeightComReqDto_10.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020707_1_44651
addTargetContCycleWeightComReqDto_10.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020706_1_44651
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_10.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020703_1_44651
addTargetContCycleWeightComReqDto_10.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020704_1_44651
    }

    /*D3-新增目标内容目标周期权重(中期：冗余中期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_10.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_10.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_14 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_10)/*vcase invoke isSameApp*/;



           }
    }
else if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("FALSE"))){
       //elseif((3-3-09查当前树叶子目标周期详情.是否子周期 等于 是 and 3-3-09查当前树叶子目标周期详情.是否中期 等于 是 and 3-3-09查当前树叶子目标周期详情.是否父周期 等于 否))  69795

AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_15 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_11=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_11.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1020692_1_69796
addTargetContCycleWeightComReqDto_11.setIsRedundantMidCycle("FALSE");//sourceId:1020693_1_69796
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_11.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020690_1_69796
addTargetContCycleWeightComReqDto_11.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020691_1_69796
addTargetContCycleWeightComReqDto_11.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020698_1_69796
addTargetContCycleWeightComReqDto_11.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020697_1_69796
    }
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_11.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020694_1_69796
addTargetContCycleWeightComReqDto_11.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020695_1_69796
    }

    /*D3-新增目标内容目标周期权重(子周期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_11.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_11.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(子周期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_15 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_11)/*vcase invoke isSameApp*/;



           }
AddTargetContCycleWeightComRespDto addTargetContCycleWeightComRespDto_16 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AddTargetContCycleWeightComReqDto addTargetContCycleWeightComReqDto_12=new AddTargetContCycleWeightComReqDto();
  addTargetContCycleWeightComReqDto_12.setParentSubMidCycleType("MID_CYCLE");//sourceId:1020701_1_69797
addTargetContCycleWeightComReqDto_12.setIsRedundantMidCycle("TRUE");//sourceId:1020702_1_69797
if(reqDto!=null){
      addTargetContCycleWeightComReqDto_12.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020699_1_69797
addTargetContCycleWeightComReqDto_12.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020703_1_69797
addTargetContCycleWeightComReqDto_12.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1020704_1_69797
    }
if(omsEvaluationObjectTargetCycle!=null){
      addTargetContCycleWeightComReqDto_12.setWeightObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1020700_1_69797
addTargetContCycleWeightComReqDto_12.setOrderNumber(omsEvaluationObjectTargetCycle.getOrderNumber());//SimpleFieldAssign//sourceId:1020707_1_69797
addTargetContCycleWeightComReqDto_12.setRelativeOrderNumber(omsEvaluationObjectTargetCycle.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1020706_1_69797
    }

    /*D3-新增目标内容目标周期权重(中期：冗余中期)[5472]   */
    Assert.isNull(addTargetContCycleWeightComReqDto_12.getEvaObjTargetCycleId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getWeightObjTypeCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-权重设置对象类型编码不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getParentSubMidCycleType(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-父子中周期类型不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getIsRedundantMidCycle(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-是否冗余中期权重不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-周期排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getRelativeOrderNumber(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-相对上级排序不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getEvaluationTemplateId(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetContCycleWeightComReqDto_12.getBatchCode(),"D3增树单叶子权重设置(公共)-D3-新增目标内容目标周期权重(中期：冗余中期)-批次标识不能为空",false);
      addTargetContCycleWeightComRespDto_16 = targetCycleService.addTargetContCycleWeightCom(addTargetContCycleWeightComReqDto_12)/*vcase invoke isSameApp*/;



           }
    }
    }
AddTreeSingleLeafWeightSetComRespDto retData = new AddTreeSingleLeafWeightSetComRespDto();





return retData;
  }
/**
   * D3回写部门目标任务书目标根节点权重分(公共)[7157]
   * gen by moon at 6/16/2024, 2:47:03 AM
   */
  @Trace(operationName = "D3回写部门目标任务书目标根节点权重分(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementWriteBackDeptObjTreeRootWeightScoreComRespDto implementWriteBackDeptObjTreeRootWeightScoreCom(ImplementWriteBackDeptObjTreeRootWeightScoreComReqDto reqDto){


      //virtualUsage D2查部门目标任务书权重分配置答案  44688
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("TARGET_TASK_FULL_TOTAL_VALUE");//CUSTOM_CONVENTION//sourceId:1022146_1_44688
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1022147_1_44688
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1022145_1_44688
    }

    /*D2查部门目标任务书权重分配置答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3回写部门目标任务书目标根节点权重分(公共)-D2查部门目标任务书权重分配置答案-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3回写部门目标任务书目标根节点权重分(公共)-D2查部门目标任务书权重分配置答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3回写部门目标任务书目标根节点权重分(公共)-D2查部门目标任务书权重分配置答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage 3-3-09查部门目标任务书目标根节点列表  44689
      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setEvaObjTypeCode("FLEVEL_OBJ_TASK_DUTY_DEPT");//sourceId:1022178_1_44689
queryEvaObjTargetCycleListReq.setTargetCycleContentTypeCode("TARGET");//sourceId:1022179_1_44689
queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1022181_1_44689
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1022177_1_44689
queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1022180_1_44689
    }

    /*3-3-09查部门目标任务书目标根节点列表[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjEntityId(),"D3回写部门目标任务书目标根节点权重分(公共)-3-3-09查部门目标任务书目标根节点列表-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTypeCode(),"D3回写部门目标任务书目标根节点权重分(公共)-3-3-09查部门目标任务书目标根节点列表-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentTypeCode(),"D3回写部门目标任务书目标根节点权重分(公共)-3-3-09查部门目标任务书目标根节点列表-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3回写部门目标任务书目标根节点权重分(公共)-3-3-09查部门目标任务书目标根节点列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3回写部门目标任务书目标根节点权重分(公共)-3-3-09查部门目标任务书目标根节点列表-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 3-3-09-02批量查询被评对象目标周期权重  44690
      List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet =new ArrayList<>();
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          BatchQueryEvaObjTargetCycleWeightReq batchQueryEvaObjTargetCycleWeightReq=new BatchQueryEvaObjTargetCycleWeightReq();
  batchQueryEvaObjTargetCycleWeightReq.setWeightObjTypeCode("FLEVEL_OBJ_TASK_DUTY_DEPT");//sourceId:1022194_1_44690
batchQueryEvaObjTargetCycleWeightReq.setIsArchive("FALSE");//sourceId:1022195_1_44690
if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      batchQueryEvaObjTargetCycleWeightReq.setEvaObjTargetCycleWeightList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1022191_1_44690
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleWeightReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1022196_1_44690
    }

    /*3-3-09-02批量查询被评对象目标周期权重[2745]   */
    Assert.isNull(batchQueryEvaObjTargetCycleWeightReq.getWeightObjTypeCode(),"D3回写部门目标任务书目标根节点权重分(公共)-3-3-09-02批量查询被评对象目标周期权重-权重设置对象类型编码不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightReq.getEvaluationTemplateId(),"D3回写部门目标任务书目标根节点权重分(公共)-3-3-09-02批量查询被评对象目标周期权重-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightReq.getIsArchive(),"D3回写部门目标任务书目标根节点权重分(公共)-3-3-09-02批量查询被评对象目标周期权重-是否存档不能为空",false);
      listOmsEvaObjTargetCycleWeightSet = mOmsEvaObjTargetCycleWeightSetService.batchQueryEvaObjTargetCycleWeight(batchQueryEvaObjTargetCycleWeightReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//virtualUsage 3-3-09-02批量改被评对象目标周期权重  44691
      boolean bOOLEAN ;
    if(listOmsEvaObjTargetCycleWeightSet !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)&& listOmsEvaObjTargetCycleWeightSet.size()>0 &&queryConfItemMatchAnswerDetailComRespDto !=null){
          List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet_2=new ArrayList<>();
  if(listOmsEvaObjTargetCycleWeightSet!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)&&  listOmsEvaObjTargetCycleWeightSet !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)){
      QueryConfItemMatchAnswerDetailComRespDto finalQueryConfItemMatchAnswerDetailComRespDto = queryConfItemMatchAnswerDetailComRespDto;
      listOmsEvaObjTargetCycleWeightSet_2 = //objList-to-objLists
        listOmsEvaObjTargetCycleWeightSet.stream().map(item -> {
      OmsEvaObjTargetCycleWeightSet elm = new OmsEvaObjTargetCycleWeightSet();
      elm.setObjTargetCycleWeightSetId(item.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:217566_2_44691
elm.setWeightValue(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:217567_2_44691
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:217569_2_44691
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:217570_2_44691
if(finalQueryConfItemMatchAnswerDetailComRespDto !=null){
      elm.setWeightScore(finalQueryConfItemMatchAnswerDetailComRespDto.getEndValue()!=null?Double.valueOf(finalQueryConfItemMatchAnswerDetailComRespDto.getEndValue()):null);//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:217568_2_44691
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1022203_1_44691
    }

    /*3-3-09-02批量改被评对象目标周期权重[3676]   */

      bOOLEAN = mOmsEvaObjTargetCycleWeightSetService.batchUpdateEvaObjTargetCycleWeight(listOmsEvaObjTargetCycleWeightSet_2)/*vcase invoke 本地 method 方法调用;*/;



           }
ImplementWriteBackDeptObjTreeRootWeightScoreComRespDto retData = new ImplementWriteBackDeptObjTreeRootWeightScoreComRespDto();





return retData;
  }
/**
   * D3执行目标内容自动更新权重分(公共)[7244]
   * gen by moon at 6/25/2023, 9:03:57 PM
   */
  @Trace(operationName = "D3执行目标内容自动更新权重分(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTargetContAutoUpdateWeightScoreComRespDto implementTargetContAutoUpdateWeightScoreCom(ImplementTargetContAutoUpdateWeightScoreComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getBatchCurrentStatus() !=null && reqDto.getBatchCurrentStatus().equals("2")||reqDto!= null&&  reqDto.getWeightSetWay() !=null && reqDto.getWeightSetWay().equals("WEI_POI_SET_MOD"))) {
        //if((D3执行目标内容自动更新权重分(公共).批次现状 等于 2 or D3执行目标内容自动更新权重分(公共).前端权重设置方式 等于 按权重分设置))  46198

ImplementAutoUpdateWeightScoreComRespDto implementAutoUpdateWeightScoreComRespDto = null;
    ImplementAutoUpdateWeightScoreComReqDto implementAutoUpdateWeightScoreComReqDto=new ImplementAutoUpdateWeightScoreComReqDto();
  if(reqDto!=null){
      implementAutoUpdateWeightScoreComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1060742_1_46199
implementAutoUpdateWeightScoreComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060740_1_46199
implementAutoUpdateWeightScoreComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1060743_1_46199
implementAutoUpdateWeightScoreComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1060744_1_46199
implementAutoUpdateWeightScoreComReqDto.setComFloatField(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1060741_1_46199
    }

    /*D3执行自动更新权重分(公共)[5523]   */
    Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getEvaObjTargetCycleId(),"D3执行目标内容自动更新权重分(公共)-D3执行自动更新权重分(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getEvaluationTemplateId(),"D3执行目标内容自动更新权重分(公共)-D3执行自动更新权重分(公共)-评价模板ID不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getObjectId(),"D3执行目标内容自动更新权重分(公共)-D3执行自动更新权重分(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getUseTypeCode(),"D3执行目标内容自动更新权重分(公共)-D3执行自动更新权重分(公共)-用途类型编码不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getComFloatField(),"D3执行目标内容自动更新权重分(公共)-D3执行自动更新权重分(公共)-通用数值字段（小数型）不能为空",false);
      implementAutoUpdateWeightScoreComRespDto = targetCycleService.implementAutoUpdateWeightScoreCom(implementAutoUpdateWeightScoreComReqDto)/*vcase invoke isSameApp*/;



      }
else{
       //else  46204

ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto=new ImplementStatisticsUpdateExecuteProgressComReqDto();
//  implementStatisticsUpdateExecuteProgressComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1060793_1_46205
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1060789_1_46205
implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1060790_1_46205
implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1060791_1_46205
implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060792_1_46205
    }

    /*D3执行统计更新执行进度(公共)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(),"D3执行目标内容自动更新权重分(公共)-D3执行统计更新执行进度(公共)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(),"D3执行目标内容自动更新权重分(公共)-D3执行统计更新执行进度(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(),"D3执行目标内容自动更新权重分(公共)-D3执行统计更新执行进度(公共)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(),"D3执行目标内容自动更新权重分(公共)-D3执行统计更新执行进度(公共)-主题内容ID不能为空",false);
//Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getOperationInductionId(),"D3执行目标内容自动更新权重分(公共)-D3执行统计更新执行进度(公共)-操作人就职记录ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;



    }
ImplementTargetContAutoUpdateWeightScoreComRespDto retData = new ImplementTargetContAutoUpdateWeightScoreComRespDto();





return retData;
  }
/**
   * D3执行高中基层权重设置[6409]
   * gen by moon at 7/14/2023, 12:16:51 AM
   */
  @Trace(operationName = "D3执行高中基层权重设置")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTopMidBasicWeightSetRespDto implementTopMidBasicWeightSet(ImplementTopMidBasicWeightSetReqDto reqDto){


      ImplementAcceptFieldRespDto receptionServiceRes_1 =null;
//virtualUsage D3执行进度运行判断(公共)  46187
      ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
    ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto=new ImplementExecuteProgressOperationJudgeComReqDto();
  implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1060142_1_46187
if(reqDto!=null){
      implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060141_1_46187
implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060143_1_46187
    }

    /*D3执行进度运行判断(公共)[7243]   */
    Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(),"D3执行高中基层权重设置-D3执行进度运行判断(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(),"D3执行高中基层权重设置-D3执行进度运行判断(公共)-用途类型编码不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(),"D3执行高中基层权重设置-D3执行进度运行判断(公共)-主题内容ID不能为空",false);
      implementExecuteProgressOperationJudgeComRespDto = executeProgressService.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3初始化更新执行进度(0%)  46244
      ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:1060877_1_46244
implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1060881_1_46244
if(reqDto!=null){
implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060880_1_46244
implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060883_1_46244
    }

    /*D3初始化更新执行进度(0%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(),"D3执行高中基层权重设置-D3初始化更新执行进度(0%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(),"D3执行高中基层权重设置-D3初始化更新执行进度(0%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(),"D3执行高中基层权重设置-D3初始化更新执行进度(0%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(),"D3执行高中基层权重设置-D3初始化更新执行进度(0%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;



if((implementExecuteProgressOperationJudgeComRespDto!= null&& implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null )) {
        //if(D3执行执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  46188

ImplementWeightSetOperateTermJudgeComRespDto implementWeightSetOperateTermJudgeComRespDto = null;
    ImplementWeightSetOperateTermJudgeComReqDto implementWeightSetOperateTermJudgeComReqDto=new ImplementWeightSetOperateTermJudgeComReqDto();
  if(reqDto!=null){
      implementWeightSetOperateTermJudgeComReqDto.setParentContId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060057_1_46191
implementWeightSetOperateTermJudgeComReqDto.setParentContTableCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1060056_1_46191
implementWeightSetOperateTermJudgeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060058_1_46191
    }

    /*D3执行权重设置操作条件判断(公共)[6347]   */
    Assert.isNull(implementWeightSetOperateTermJudgeComReqDto.getParentContId(),"D3执行高中基层权重设置-D3执行权重设置操作条件判断(公共)-父级内容表主键ID不能为空",false);
Assert.isNull(implementWeightSetOperateTermJudgeComReqDto.getParentContTableCode(),"D3执行高中基层权重设置-D3执行权重设置操作条件判断(公共)-父级内容表类型编码不能为空",false);
Assert.isNull(implementWeightSetOperateTermJudgeComReqDto.getEvaluationTemplateId(),"D3执行高中基层权重设置-D3执行权重设置操作条件判断(公共)-冗余评价模板ID不能为空",false);
      implementWeightSetOperateTermJudgeComRespDto = targetContentService.implementWeightSetOperateTermJudgeCom(implementWeightSetOperateTermJudgeComReqDto)/*vcase invoke isSameApp*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_1 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_1=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_1.setExecuteProgressValue(Double.valueOf("3"));//CUSTOM_CONVENTION//sourceId:1060888_1_46243
implementStatisticsUpdateExecuteProgressComReqDto_1.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1060892_1_46243
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_1.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060891_1_46243
implementStatisticsUpdateExecuteProgressComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060894_1_46243
    }

    /*D3统计更新执行进度(3%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getExecuteProgressValue(),"D3执行高中基层权重设置-D3统计更新执行进度(3%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getObjectId(),"D3执行高中基层权重设置-D3统计更新执行进度(3%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getUseTypeCode(),"D3执行高中基层权重设置-D3统计更新执行进度(3%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getThemeContentId(),"D3执行高中基层权重设置-D3统计更新执行进度(3%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_1 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_1)/*vcase invoke isSameApp*/;



if((implementWeightSetOperateTermJudgeComRespDto!= null&& implementWeightSetOperateTermJudgeComRespDto.getCustomField() == null )) {
        //if(D3执行权重设置操作条件判断(公共).上级权重未设置故事文案 值等于空 )  46192

ImplementWeightRationalityVerifyComRespDto implementWeightRationalityVerifyComRespDto = null;
    ImplementWeightRationalityVerifyComReqDto implementWeightRationalityVerifyComReqDto=new ImplementWeightRationalityVerifyComReqDto();
  if(reqDto!= null&&  reqDto.getEvaObjTargetCycleWeightList() !=null&& !CollectionUtil.isEmpty(reqDto.getEvaObjTargetCycleWeightList())){
      implementWeightRationalityVerifyComReqDto.setEvaObjTargetCycleWeightList(reqDto.getEvaObjTargetCycleWeightList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1060438_1_46195
    }
if(reqDto!=null){
      implementWeightRationalityVerifyComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1060439_1_46195
implementWeightRationalityVerifyComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060440_1_46195
implementWeightRationalityVerifyComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060443_1_46195
implementWeightRationalityVerifyComReqDto.setCloneSubCycle(reqDto.getCloneSubCycle());//SimpleFieldAssign//sourceId:1060441_1_46195
    }

    /*D3执行权重设置合理性校验(公共)[5685]   */
    Assert.isNull(implementWeightRationalityVerifyComReqDto.getTableTypeCode(),"D3执行高中基层权重设置-D3执行权重设置合理性校验(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(implementWeightRationalityVerifyComReqDto.getEntityId(),"D3执行高中基层权重设置-D3执行权重设置合理性校验(公共)-冗余内容表主键ID不能为空",false);
Assert.isNull(implementWeightRationalityVerifyComReqDto.getEvaluationTemplateId(),"D3执行高中基层权重设置-D3执行权重设置合理性校验(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementWeightRationalityVerifyComReqDto.getCloneSubCycle(),"D3执行高中基层权重设置-D3执行权重设置合理性校验(公共)-用于判断克隆子中周期不能为空",false);
      implementWeightRationalityVerifyComRespDto = targetContentService.implementWeightRationalityVerifyCom(implementWeightRationalityVerifyComReqDto)/*vcase invoke isSameApp*/;



if((implementWeightRationalityVerifyComRespDto!= null&& implementWeightRationalityVerifyComRespDto.getObjectName() == null )) {
        //if(D3执行权重设置合理性校验(公共).权重设置验证未通过故事文案 值等于空 )  46196

ImplementSetTargetCycleWeightComRespDto implementSetTargetCycleWeightComRespDto = null;
    ImplementSetTargetCycleWeightComReqDto implementSetTargetCycleWeightComReqDto=new ImplementSetTargetCycleWeightComReqDto();
  if(reqDto!= null&&  reqDto.getEvaObjTargetCycleWeightList() !=null&& !CollectionUtil.isEmpty(reqDto.getEvaObjTargetCycleWeightList())){
      implementSetTargetCycleWeightComReqDto.setEvaObjTargetCycleWeightList(reqDto.getEvaObjTargetCycleWeightList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1060794_1_46208
    }
if(reqDto!=null){
      implementSetTargetCycleWeightComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1060795_1_46208
implementSetTargetCycleWeightComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060796_1_46208
implementSetTargetCycleWeightComReqDto.setWeightObjTypeCode(reqDto.getWeightObjTypeCode());//SimpleFieldAssign//sourceId:1060798_1_46208
implementSetTargetCycleWeightComReqDto.setCloneSubCycle(reqDto.getCloneSubCycle());//SimpleFieldAssign//sourceId:1060797_1_46208
implementSetTargetCycleWeightComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1060800_1_46208
implementSetTargetCycleWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060803_1_46208
implementSetTargetCycleWeightComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1060799_1_46208
implementSetTargetCycleWeightComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:1060801_1_46208
implementSetTargetCycleWeightComReqDto.setWeightSetWay(reqDto.getWeightSetWay());//SimpleFieldAssign//sourceId:1060804_1_46208
implementSetTargetCycleWeightComReqDto.setBatchOperateScene(reqDto.getBatchOperateScene());//SimpleFieldAssign//sourceId:1060802_1_46208
    }

    /*D3执行设置目标周期权重(公共)[5690]   */
    Assert.isNull(implementSetTargetCycleWeightComReqDto.getTableTypeCode(),"D3执行高中基层权重设置-D3执行设置目标周期权重(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(implementSetTargetCycleWeightComReqDto.getEntityId(),"D3执行高中基层权重设置-D3执行设置目标周期权重(公共)-冗余内容表主键ID不能为空",false);
Assert.isNull(implementSetTargetCycleWeightComReqDto.getWeightObjTypeCode(),"D3执行高中基层权重设置-D3执行设置目标周期权重(公共)-权重设置对象类型编码不能为空",false);
Assert.isNull(implementSetTargetCycleWeightComReqDto.getCloneSubCycle(),"D3执行高中基层权重设置-D3执行设置目标周期权重(公共)-用于判断克隆子中周期不能为空",false);
Assert.isNull(implementSetTargetCycleWeightComReqDto.getEvaluationTemplateId(),"D3执行高中基层权重设置-D3执行设置目标周期权重(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementSetTargetCycleWeightComReqDto.getBatchCode(),"D3执行高中基层权重设置-D3执行设置目标周期权重(公共)-批次标识不能为空",false);
Assert.isNull(implementSetTargetCycleWeightComReqDto.getBatchCurrentStatus(),"D3执行高中基层权重设置-D3执行设置目标周期权重(公共)-批次现状不能为空",false);
Assert.isNull(implementSetTargetCycleWeightComReqDto.getWeightSetWay(),"D3执行高中基层权重设置-D3执行设置目标周期权重(公共)-前端权重设置方式不能为空",false);
Assert.isNull(implementSetTargetCycleWeightComReqDto.getBatchOperateScene(),"D3执行高中基层权重设置-D3执行设置目标周期权重(公共)-高/中/基层操作场景不能为空",false);
      implementSetTargetCycleWeightComRespDto = targetContentService.implementSetTargetCycleWeightCom(implementSetTargetCycleWeightComReqDto)/*vcase invoke isSameApp*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_2 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_2=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_2.setIsComplete("TRUE");//sourceId:1060954_1_46256
implementStatisticsUpdateExecuteProgressComReqDto_2.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1060956_1_46256
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_2.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060955_1_46256
implementStatisticsUpdateExecuteProgressComReqDto_2.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060957_1_46256
    }

    /*D3更新执行进度(已完成）[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getIsComplete(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-是否已完成不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getObjectId(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getUseTypeCode(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getThemeContentId(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_2 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_2)/*vcase invoke isSameApp*/;



      }
else{
       //else  46206

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    if(implementWeightRationalityVerifyComRespDto !=null){
    ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  if(implementWeightRationalityVerifyComRespDto!=null){
      receptionServiceReq.setCustomField1(implementWeightRationalityVerifyComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1086266_1_46207
    }

    /*M3接收权重设置异常故事文案[6100]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbWeightTarget.implementAcceptField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_3 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_3=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_3.setExecuteProgressValue(Double.valueOf("80"));//CUSTOM_CONVENTION//sourceId:1060944_1_46251
implementStatisticsUpdateExecuteProgressComReqDto_3.setUseTypeCode("80");//CUSTOM_CONVENTION//sourceId:1060946_1_46251
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_3.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060945_1_46251
implementStatisticsUpdateExecuteProgressComReqDto_3.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060947_1_46251
    }

    /*D3统计更新执行进度(80%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getExecuteProgressValue(),"D3执行高中基层权重设置-D3统计更新执行进度(80%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getObjectId(),"D3执行高中基层权重设置-D3统计更新执行进度(80%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getUseTypeCode(),"D3执行高中基层权重设置-D3统计更新执行进度(80%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getThemeContentId(),"D3执行高中基层权重设置-D3统计更新执行进度(80%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_3 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_3)/*vcase invoke isSameApp*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_4 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_4=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_4.setIsComplete("TRUE");//sourceId:1060954_1_46253
implementStatisticsUpdateExecuteProgressComReqDto_4.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1060956_1_46253
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_4.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060955_1_46253
implementStatisticsUpdateExecuteProgressComReqDto_4.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060957_1_46253
    }

    /*D3更新执行进度(已完成）[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getIsComplete(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-是否已完成不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getObjectId(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getUseTypeCode(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getThemeContentId(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_4 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_4)/*vcase invoke isSameApp*/;



    }
      }
else{
       //else  46193

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    if(implementWeightSetOperateTermJudgeComRespDto !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  if(implementWeightSetOperateTermJudgeComRespDto!=null){
      receptionServiceReq_1.setCustomField1(implementWeightSetOperateTermJudgeComRespDto.getCustomField());//SimpleFieldAssign//sourceId:1086266_1_46194
    }

    /*M3接收权重设置异常故事文案[6100]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbWeightTarget.implementAcceptField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_5 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_5=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_5.setExecuteProgressValue(Double.valueOf("97"));//CUSTOM_CONVENTION//sourceId:1060949_1_46252
implementStatisticsUpdateExecuteProgressComReqDto_5.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1060951_1_46252
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_5.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060950_1_46252
implementStatisticsUpdateExecuteProgressComReqDto_5.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060952_1_46252
    }

    /*D3更新执行进度(97%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getExecuteProgressValue(),"D3执行高中基层权重设置-D3更新执行进度(97%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getObjectId(),"D3执行高中基层权重设置-D3更新执行进度(97%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getUseTypeCode(),"D3执行高中基层权重设置-D3更新执行进度(97%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getThemeContentId(),"D3执行高中基层权重设置-D3更新执行进度(97%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_5 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_5)/*vcase invoke isSameApp*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_6 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_6=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_6.setIsComplete("TRUE");//sourceId:1060954_1_46255
implementStatisticsUpdateExecuteProgressComReqDto_6.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1060956_1_46255
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_6.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060955_1_46255
implementStatisticsUpdateExecuteProgressComReqDto_6.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060957_1_46255
    }

    /*D3更新执行进度(已完成）[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getIsComplete(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-是否已完成不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getObjectId(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getUseTypeCode(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getThemeContentId(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_6 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_6)/*vcase invoke isSameApp*/;



    }
      }
else{
       //else  46189

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_3 = null;
    if(implementExecuteProgressOperationJudgeComRespDto !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_2=new ImplementAcceptFieldReqDto();
  if(implementExecuteProgressOperationJudgeComRespDto!=null){
      receptionServiceReq_2.setCustomField(implementExecuteProgressOperationJudgeComRespDto.getCustomField());//SimpleFieldAssign//sourceId:1060436_1_46190
    }

    /*M3接收权重设置异常故事文案[6100]  用于特殊方法接收上游入参。 */

      receptionServiceRes_3 = nbWeightTarget.implementAcceptField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_7 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_7=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_7.setIsComplete("TRUE");//sourceId:1060954_1_46254
implementStatisticsUpdateExecuteProgressComReqDto_7.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1060956_1_46254
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_7.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1060955_1_46254
implementStatisticsUpdateExecuteProgressComReqDto_7.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1060957_1_46254
    }

    /*D3更新执行进度(已完成）[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getIsComplete(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-是否已完成不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getObjectId(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getUseTypeCode(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getThemeContentId(),"D3执行高中基层权重设置-D3更新执行进度(已完成）-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_7 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_7)/*vcase invoke isSameApp*/;



    }
ImplementTopMidBasicWeightSetRespDto retData = new ImplementTopMidBasicWeightSetRespDto();
  if(receptionServiceRes_1!=null){
      retData.setCustomField(receptionServiceRes_1.getCustomField());//SimpleFieldAssign//sourceId:1060444_1
retData.setCustomField1(receptionServiceRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1086268_1
    }




return retData;
  }
/**
   * D3执行部门目标任务书叶子权重设置(公共)[7245]
   * gen by moon at 7/14/2023, 12:17:32 AM
   */
  @Trace(operationName = "D3执行部门目标任务书叶子权重设置(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDeptObjTaskLeafWeightSetComRespDto implementDeptObjTaskLeafWeightSetCom(ImplementDeptObjTaskLeafWeightSetComReqDto reqDto){


      ImplementAcceptFieldRespDto receptionServiceRes_1 =null;
//virtualUsage D3执行进度运行判断(公共)  46257
      ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeComRespDto = null;
    ImplementExecuteProgressOperationJudgeComReqDto implementExecuteProgressOperationJudgeComReqDto=new ImplementExecuteProgressOperationJudgeComReqDto();
  implementExecuteProgressOperationJudgeComReqDto.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1061251_1_46257
if(reqDto!=null){
      implementExecuteProgressOperationJudgeComReqDto.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061250_1_46257
implementExecuteProgressOperationJudgeComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061252_1_46257
    }

    /*D3执行进度运行判断(公共)[7243]   */
    Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getObjectId(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行进度运行判断(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getUseTypeCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行进度运行判断(公共)-用途类型编码不能为空",false);
Assert.isNull(implementExecuteProgressOperationJudgeComReqDto.getThemeContentId(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行进度运行判断(公共)-主题内容ID不能为空",false);
      implementExecuteProgressOperationJudgeComRespDto = executeProgressService.implementExecuteProgressOperationJudgeCom(implementExecuteProgressOperationJudgeComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3初始化执行进度(0%)  46258
      ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:1061336_1_46258
implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1061339_1_46258
if(reqDto!=null){
implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061338_1_46258
implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061340_1_46258
    }

    /*D3初始化执行进度(0%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(),"D3执行部门目标任务书叶子权重设置(公共)-D3初始化执行进度(0%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(),"D3执行部门目标任务书叶子权重设置(公共)-D3初始化执行进度(0%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3初始化执行进度(0%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(),"D3执行部门目标任务书叶子权重设置(公共)-D3初始化执行进度(0%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;



if((implementExecuteProgressOperationJudgeComRespDto!= null&& implementExecuteProgressOperationJudgeComRespDto.getCustomField() == null )) {
        //if(D3执行进度运行判断(公共).操作过于频繁，请稍后再试文案故事 值等于空 )  46259

ImplementWeightSetOperateTermJudgeComRespDto implementWeightSetOperateTermJudgeComRespDto = null;
    ImplementWeightSetOperateTermJudgeComReqDto implementWeightSetOperateTermJudgeComReqDto=new ImplementWeightSetOperateTermJudgeComReqDto();
  if(reqDto!=null){
      implementWeightSetOperateTermJudgeComReqDto.setParentContTableCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1061254_1_46261
implementWeightSetOperateTermJudgeComReqDto.setParentContId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061255_1_46261
implementWeightSetOperateTermJudgeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061256_1_46261
    }

    /*D3执行权重设置操作条件判断(公共)[6347]   */
    Assert.isNull(implementWeightSetOperateTermJudgeComReqDto.getParentContTableCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行权重设置操作条件判断(公共)-父级内容表类型编码不能为空",false);
Assert.isNull(implementWeightSetOperateTermJudgeComReqDto.getParentContId(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行权重设置操作条件判断(公共)-父级内容表主键ID不能为空",false);
Assert.isNull(implementWeightSetOperateTermJudgeComReqDto.getEvaluationTemplateId(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行权重设置操作条件判断(公共)-冗余评价模板ID不能为空",false);
      implementWeightSetOperateTermJudgeComRespDto = targetContentService.implementWeightSetOperateTermJudgeCom(implementWeightSetOperateTermJudgeComReqDto)/*vcase invoke isSameApp*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_1 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_1=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_1.setExecuteProgressValue(Double.valueOf("3"));//CUSTOM_CONVENTION//sourceId:1061652_1_46271
implementStatisticsUpdateExecuteProgressComReqDto_1.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1061654_1_46271
//implementStatisticsUpdateExecuteProgressComReqDto_1.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1061656_1_46271
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_1.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061653_1_46271
implementStatisticsUpdateExecuteProgressComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061655_1_46271
    }

    /*D3统计更新执行进度(3%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getExecuteProgressValue(),"D3执行部门目标任务书叶子权重设置(公共)-D3统计更新执行进度(3%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getObjectId(),"D3执行部门目标任务书叶子权重设置(公共)-D3统计更新执行进度(3%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getUseTypeCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3统计更新执行进度(3%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getThemeContentId(),"D3执行部门目标任务书叶子权重设置(公共)-D3统计更新执行进度(3%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_1 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_1)/*vcase invoke isSameApp*/;



if((implementWeightSetOperateTermJudgeComRespDto!= null&& implementWeightSetOperateTermJudgeComRespDto.getCustomField() == null )) {
        //if(D3执行权重设置操作条件判断(公共).上级权重未设置故事文案 值等于空 )  46262

ImplementWeightRationalityVerifyComRespDto implementWeightRationalityVerifyComRespDto = null;
    ImplementWeightRationalityVerifyComReqDto implementWeightRationalityVerifyComReqDto=new ImplementWeightRationalityVerifyComReqDto();
  if(reqDto!= null&&  reqDto.getEvaObjTargetCycleWeightList() !=null&& !CollectionUtil.isEmpty(reqDto.getEvaObjTargetCycleWeightList())){
      implementWeightRationalityVerifyComReqDto.setEvaObjTargetCycleWeightList(reqDto.getEvaObjTargetCycleWeightList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1061258_1_46263
    }
if(reqDto!=null){
      implementWeightRationalityVerifyComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1061259_1_46263
implementWeightRationalityVerifyComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061260_1_46263
implementWeightRationalityVerifyComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061263_1_46263
implementWeightRationalityVerifyComReqDto.setCloneSubCycle(reqDto.getCloneSubCycle());//SimpleFieldAssign//sourceId:1061261_1_46263
    }

    /*D3执行权重设置合理性校验(公共)[5685]   */
    Assert.isNull(implementWeightRationalityVerifyComReqDto.getTableTypeCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行权重设置合理性校验(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(implementWeightRationalityVerifyComReqDto.getEntityId(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行权重设置合理性校验(公共)-冗余内容表主键ID不能为空",false);
Assert.isNull(implementWeightRationalityVerifyComReqDto.getEvaluationTemplateId(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行权重设置合理性校验(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementWeightRationalityVerifyComReqDto.getCloneSubCycle(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行权重设置合理性校验(公共)-用于判断克隆子中周期不能为空",false);
      implementWeightRationalityVerifyComRespDto = targetContentService.implementWeightRationalityVerifyCom(implementWeightRationalityVerifyComReqDto)/*vcase invoke isSameApp*/;



if((implementWeightRationalityVerifyComRespDto!= null&& implementWeightRationalityVerifyComRespDto.getObjectName() == null )) {
        //if(D3执行权重设置合理性校验(公共).权重设置验证未通过故事文案 值等于空 )  46264

ImplementSetDeptObjTaskWeightComRespDto implementSetDeptObjTaskWeightComRespDto = null;
    ImplementSetDeptObjTaskWeightComReqDto implementSetDeptObjTaskWeightComReqDto=new ImplementSetDeptObjTaskWeightComReqDto();
  if(reqDto!= null&&  reqDto.getEvaObjTargetCycleWeightList() !=null&& !CollectionUtil.isEmpty(reqDto.getEvaObjTargetCycleWeightList())){
      implementSetDeptObjTaskWeightComReqDto.setEvaObjTargetCycleWeightList(reqDto.getEvaObjTargetCycleWeightList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1061274_1_46265
    }
if(reqDto!=null){
      implementSetDeptObjTaskWeightComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1061275_1_46265
implementSetDeptObjTaskWeightComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061276_1_46265
implementSetDeptObjTaskWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061277_1_46265
implementSetDeptObjTaskWeightComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1061278_1_46265
implementSetDeptObjTaskWeightComReqDto.setBatchCurrentStatus(reqDto.getBatchCurrentStatus());//SimpleFieldAssign//sourceId:1061279_1_46265
implementSetDeptObjTaskWeightComReqDto.setCloneSubCycle(reqDto.getCloneSubCycle());//SimpleFieldAssign//sourceId:1061280_1_46265
    }

    /*D3执行部门目标任务书权重(公共)[7203]   */
    Assert.isNull(implementSetDeptObjTaskWeightComReqDto.getTableTypeCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行部门目标任务书权重(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(implementSetDeptObjTaskWeightComReqDto.getEntityId(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行部门目标任务书权重(公共)-冗余内容表主键ID不能为空",false);
Assert.isNull(implementSetDeptObjTaskWeightComReqDto.getEvaluationTemplateId(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行部门目标任务书权重(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementSetDeptObjTaskWeightComReqDto.getBatchCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行部门目标任务书权重(公共)-批次标识不能为空",false);
Assert.isNull(implementSetDeptObjTaskWeightComReqDto.getBatchCurrentStatus(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行部门目标任务书权重(公共)-批次现状不能为空",false);
Assert.isNull(implementSetDeptObjTaskWeightComReqDto.getCloneSubCycle(),"D3执行部门目标任务书叶子权重设置(公共)-D3执行部门目标任务书权重(公共)-用于判断克隆子中周期不能为空",false);
      implementSetDeptObjTaskWeightComRespDto = targetContentService.implementSetDeptObjTaskWeightCom(implementSetDeptObjTaskWeightComReqDto)/*vcase invoke isSameApp*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_2 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_2=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_2.setIsComplete("TRUE");//sourceId:1061671_1_46272
implementStatisticsUpdateExecuteProgressComReqDto_2.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1061673_1_46272
//implementStatisticsUpdateExecuteProgressComReqDto_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1061675_1_46272
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_2.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061672_1_46272
implementStatisticsUpdateExecuteProgressComReqDto_2.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061674_1_46272
    }

    /*D3更新执行进度(已完成)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getIsComplete(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-是否已完成不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getObjectId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getUseTypeCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getThemeContentId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_2 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_2)/*vcase invoke isSameApp*/;



      }
else{
       //else  46269

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    if(implementWeightRationalityVerifyComRespDto !=null){
          ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  if(implementWeightRationalityVerifyComRespDto!=null){
      receptionServiceReq.setCustomField1(implementWeightRationalityVerifyComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1086273_1_46270
    }

    /*M3接收异常故事文案[6100]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbWeightTarget.implementAcceptField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_3 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_3=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_3.setExecuteProgressValue(Double.valueOf("80"));//CUSTOM_CONVENTION//sourceId:1061676_1_46273
implementStatisticsUpdateExecuteProgressComReqDto_3.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1061678_1_46273
//implementStatisticsUpdateExecuteProgressComReqDto_3.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1061680_1_46273
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_3.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061677_1_46273
implementStatisticsUpdateExecuteProgressComReqDto_3.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061679_1_46273
    }

    /*D3更新执行进度(80%）[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getExecuteProgressValue(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(80%）-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getObjectId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(80%）-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getUseTypeCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(80%）-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getThemeContentId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(80%）-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_3 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_3)/*vcase invoke isSameApp*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_4 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_4=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_4.setIsComplete("TRUE");//sourceId:1061671_1_46274
implementStatisticsUpdateExecuteProgressComReqDto_4.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1061673_1_46274
//implementStatisticsUpdateExecuteProgressComReqDto_4.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1061675_1_46274
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_4.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061672_1_46274
implementStatisticsUpdateExecuteProgressComReqDto_4.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061674_1_46274
    }

    /*D3更新执行进度(已完成)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getIsComplete(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-是否已完成不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getObjectId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getUseTypeCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getThemeContentId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_4 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_4)/*vcase invoke isSameApp*/;



    }
      }
else{
       //else  46266

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    if(implementWeightSetOperateTermJudgeComRespDto !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  if(implementWeightSetOperateTermJudgeComRespDto!=null){
      receptionServiceReq_1.setCustomField1(implementWeightSetOperateTermJudgeComRespDto.getCustomField());//SimpleFieldAssign//sourceId:1086273_1_46267
    }

    /*M3接收异常故事文案[6100]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbWeightTarget.implementAcceptField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_5 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_5=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_5.setExecuteProgressValue(Double.valueOf("97"));//CUSTOM_CONVENTION//sourceId:1061681_1_46275
implementStatisticsUpdateExecuteProgressComReqDto_5.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1061683_1_46275
//implementStatisticsUpdateExecuteProgressComReqDto_5.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1061685_1_46275
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_5.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061682_1_46275
implementStatisticsUpdateExecuteProgressComReqDto_5.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061684_1_46275
    }

    /*D3更新执行进度(97%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getExecuteProgressValue(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(97%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getObjectId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(97%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getUseTypeCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(97%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getThemeContentId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(97%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_5 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_5)/*vcase invoke isSameApp*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_6 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_6=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_6.setIsComplete("TRUE");//sourceId:1061671_1_46276
implementStatisticsUpdateExecuteProgressComReqDto_6.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1061673_1_46276
//implementStatisticsUpdateExecuteProgressComReqDto_6.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1061675_1_46276
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_6.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061672_1_46276
implementStatisticsUpdateExecuteProgressComReqDto_6.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061674_1_46276
    }

    /*D3更新执行进度(已完成)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getIsComplete(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-是否已完成不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getObjectId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getUseTypeCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getThemeContentId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_6 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_6)/*vcase invoke isSameApp*/;



    }
      }
else{
       //else  46260

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_3 = null;
    if(implementExecuteProgressOperationJudgeComRespDto !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_2=new ImplementAcceptFieldReqDto();
  if(implementExecuteProgressOperationJudgeComRespDto!=null){
      receptionServiceReq_2.setCustomField(implementExecuteProgressOperationJudgeComRespDto.getCustomField());//SimpleFieldAssign//sourceId:1061651_1_46268
    }

    /*M3接收异常故事文案[6100]  用于特殊方法接收上游入参。 */

      receptionServiceRes_3 = nbWeightTarget.implementAcceptField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_7 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_7=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_7.setIsComplete("TRUE");//sourceId:1061671_1_46277
implementStatisticsUpdateExecuteProgressComReqDto_7.setUseTypeCode("USE_SET_WEIGHT");//CUSTOM_CONVENTION//sourceId:1061673_1_46277
//implementStatisticsUpdateExecuteProgressComReqDto_7.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1061675_1_46277
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_7.setObjectId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1061672_1_46277
implementStatisticsUpdateExecuteProgressComReqDto_7.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061674_1_46277
    }

    /*D3更新执行进度(已完成)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getIsComplete(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-是否已完成不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getObjectId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getUseTypeCode(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getThemeContentId(),"D3执行部门目标任务书叶子权重设置(公共)-D3更新执行进度(已完成)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_7 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_7)/*vcase invoke isSameApp*/;



    }
ImplementDeptObjTaskLeafWeightSetComRespDto retData = new ImplementDeptObjTaskLeafWeightSetComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setCustomField(receptionServiceRes_1.getCustomField());//SimpleFieldAssign//sourceId:1061700_1
retData.setCustomField1(receptionServiceRes_1.getCustomField1());//SimpleFieldAssign//sourceId:1086275_1
    }




return retData;
  }
/**
   * D3执行部门指标自动更新权重分(公共)[7246]
   * gen by moon at 7/12/2023, 12:15:13 PM
   */
  @Trace(operationName = "D3执行部门指标自动更新权重分(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDeptObjAutoUpdateWeightScoreComRespDto implementDeptObjAutoUpdateWeightScoreCom(ImplementDeptObjAutoUpdateWeightScoreComReqDto reqDto){


      //virtualUsage 3-6-03查部门负责的指标列表  46300
      List<OmsVirtualOrgMemberDept> listOmsVirtualOrgMemberDept =new ArrayList<>();
    QueryVirtualOrgMemberDeptListReq queryVirtualOrgMemberDeptListReq=new QueryVirtualOrgMemberDeptListReq();
  queryVirtualOrgMemberDeptListReq.setDeptType("LEAD_DEPT");//sourceId:1062479_1_46300
queryVirtualOrgMemberDeptListReq.setTableTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:1062480_1_46300
queryVirtualOrgMemberDeptListReq.setIsArchive("FALSE");//sourceId:1062482_1_46300
if(reqDto!=null){
      queryVirtualOrgMemberDeptListReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1062478_1_46300
queryVirtualOrgMemberDeptListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1062481_1_46300
    }

    /*3-6-03查部门负责的指标列表[2220]   */
    Assert.isNull(queryVirtualOrgMemberDeptListReq.getDeptId(),"D3执行部门指标自动更新权重分(公共)-3-6-03查部门负责的指标列表-虚拟组织下部门ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberDeptListReq.getDeptType(),"D3执行部门指标自动更新权重分(公共)-3-6-03查部门负责的指标列表-部门类型编码不能为空",false);
Assert.isNull(queryVirtualOrgMemberDeptListReq.getTableTypeCode(),"D3执行部门指标自动更新权重分(公共)-3-6-03查部门负责的指标列表-冗余内容表类型编码不能为空",false);
Assert.isNull(queryVirtualOrgMemberDeptListReq.getEvaluationTemplateId(),"D3执行部门指标自动更新权重分(公共)-3-6-03查部门负责的指标列表-归属对象ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberDeptListReq.getIsArchive(),"D3执行部门指标自动更新权重分(公共)-3-6-03查部门负责的指标列表-是否存档不能为空",false);
      listOmsVirtualOrgMemberDept = mOmsVirtualOrgMemberDeptService.queryVirtualOrgMemberDeptList(queryVirtualOrgMemberDeptListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsVirtualOrgMemberDept!= null&&  listOmsVirtualOrgMemberDept !=null && listOmsVirtualOrgMemberDept.size()>0)) {
        //if(3-6-03查部门负责的指标列表.虚拟成员部门列表数据集条数 大于 0)  46301

List<OmsTargetObjective> listOmsTargetObjective =new ArrayList<>();
    if(listOmsVirtualOrgMemberDept !=null&& !CollectionUtil.isEmpty(listOmsVirtualOrgMemberDept)&& listOmsVirtualOrgMemberDept.size()>0 ){
          BatchQueryTargetObjListReq batchQueryTargetObjListReq=new BatchQueryTargetObjListReq();
  batchQueryTargetObjListReq.setIsLastObjective("FALSE");//sourceId:1062508_1_46302
batchQueryTargetObjListReq.setIsArchive("FALSE");//sourceId:1062487_1_46302
if(listOmsVirtualOrgMemberDept!= null&& !CollectionUtil.isEmpty(listOmsVirtualOrgMemberDept)&&  listOmsVirtualOrgMemberDept !=null&& !CollectionUtil.isEmpty(listOmsVirtualOrgMemberDept)){
      batchQueryTargetObjListReq.setTargetObjList(listOmsVirtualOrgMemberDept.stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1062483_1_46302
    }
if(reqDto!=null){
      batchQueryTargetObjListReq.setLevelNumber(reqDto.getLevelNumber());//SimpleFieldAssign//sourceId:1062489_1_46302
batchQueryTargetObjListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1062494_1_46302
    }

    /*3-3-03批量查指标列表（非末级指标）[2203]   */
    Assert.isNull(batchQueryTargetObjListReq.getEvaluationTemplateId(),"D3执行部门指标自动更新权重分(公共)-3-3-03批量查指标列表（非末级指标）-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryTargetObjListReq.getIsLastObjective(),"D3执行部门指标自动更新权重分(公共)-3-3-03批量查指标列表（非末级指标）-是否末级指标不能为空",false);
Assert.isNull(batchQueryTargetObjListReq.getIsArchive(),"D3执行部门指标自动更新权重分(公共)-3-3-03批量查指标列表（非末级指标）-是否存档不能为空",false);
      listOmsTargetObjective = mOmsTargetObjectiveService.batchQueryTargetObjList(batchQueryTargetObjListReq)/*vcase invoke 本地 method 方法调用;*/;



           }
ImplementCountDataSingleProgressComRespDto implementCountDataSingleProgressComRespDto = null;
    if(listOmsTargetObjective !=null&& !CollectionUtil.isEmpty(listOmsTargetObjective)&& listOmsTargetObjective.size()>0 ){
          ImplementCountDataSingleProgressComReqDto implementCountDataSingleProgressComReqDto=new ImplementCountDataSingleProgressComReqDto();
  if(listOmsTargetObjective!= null&& !CollectionUtil.isEmpty(listOmsTargetObjective)&&  listOmsTargetObjective !=null&& !CollectionUtil.isEmpty(listOmsTargetObjective)){
      implementCountDataSingleProgressComReqDto.setCountNumberDataSetsList(listOmsTargetObjective.stream().map(item->item.getObjectiveId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1062598_1_46307
    }
if(reqDto!=null){
      implementCountDataSingleProgressComReqDto.setCalcPara1(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1062600_1_46307
    }

    /*D3计算数据集单条进度值(公共)[6561]   */
    Assert.isNull(implementCountDataSingleProgressComReqDto.getCalcPara1(),"D3执行部门指标自动更新权重分(公共)-D3计算数据集单条进度值(公共)-被除数值不能为空",false);
      implementCountDataSingleProgressComRespDto = progressPublicTechnicaCapacityService.implementCountDataSingleProgressCom(implementCountDataSingleProgressComReqDto)/*vcase invoke isSameApp*/;



           }
//ModelCode: circulationCollections
        for (OmsTargetObjective circulationCollectionsRes: listOmsTargetObjective){

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1062585_1_46306
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1062586_1_46306
queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:1062588_1_46306
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1062590_1_46306
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(circulationCollectionsRes.getObjectiveId());//SimpleFieldAssign//sourceId:1062587_1_46306
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1062589_1_46306
    }

    /*3-3-09查当前牌指标目标父周期ID[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3执行部门指标自动更新权重分(公共)-3-3-09查当前牌指标目标父周期ID-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3执行部门指标自动更新权重分(公共)-3-3-09查当前牌指标目标父周期ID-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3执行部门指标自动更新权重分(公共)-3-3-09查当前牌指标目标父周期ID-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3执行部门指标自动更新权重分(公共)-3-3-09查当前牌指标目标父周期ID-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3执行部门指标自动更新权重分(公共)-3-3-09查当前牌指标目标父周期ID-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3执行部门指标自动更新权重分(公共)-3-3-09查当前牌指标目标父周期ID-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



ImplementAutoUpdateWeightScoreComRespDto implementAutoUpdateWeightScoreComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null&&implementCountDataSingleProgressComRespDto !=null){
          ImplementAutoUpdateWeightScoreComReqDto implementAutoUpdateWeightScoreComReqDto=new ImplementAutoUpdateWeightScoreComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      implementAutoUpdateWeightScoreComReqDto.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1061736_1_46305
    }
if(reqDto!=null){
      implementAutoUpdateWeightScoreComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1061734_1_46305
implementAutoUpdateWeightScoreComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1061737_1_46305
implementAutoUpdateWeightScoreComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1061738_1_46305
    }
if(implementCountDataSingleProgressComRespDto!=null){
      implementAutoUpdateWeightScoreComReqDto.setComFloatField(implementCountDataSingleProgressComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1061735_1_46305
    }

    /*D3执行自动更新权重分(公共)[5523]   */
    Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getEvaObjTargetCycleId(),"D3执行部门指标自动更新权重分(公共)-D3执行自动更新权重分(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getEvaluationTemplateId(),"D3执行部门指标自动更新权重分(公共)-D3执行自动更新权重分(公共)-评价模板ID不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getObjectId(),"D3执行部门指标自动更新权重分(公共)-D3执行自动更新权重分(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getUseTypeCode(),"D3执行部门指标自动更新权重分(公共)-D3执行自动更新权重分(公共)-用途类型编码不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getComFloatField(),"D3执行部门指标自动更新权重分(公共)-D3执行自动更新权重分(公共)-通用数值字段（小数型）不能为空",false);
      implementAutoUpdateWeightScoreComRespDto = targetCycleService.implementAutoUpdateWeightScoreCom(implementAutoUpdateWeightScoreComReqDto)/*vcase invoke isSameApp*/;



           }
//ModelCode: circulationEnd
        }

      }
else{
       //else  46325

ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto=new ImplementStatisticsUpdateExecuteProgressComReqDto();
//  implementStatisticsUpdateExecuteProgressComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1062770_1_46326
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1062766_1_46326
implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1062767_1_46326
implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1062768_1_46326
implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1062769_1_46326
    }

    /*D3统计更新执行进度(入参进度值)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(),"D3执行部门指标自动更新权重分(公共)-D3统计更新执行进度(入参进度值)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(),"D3执行部门指标自动更新权重分(公共)-D3统计更新执行进度(入参进度值)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(),"D3执行部门指标自动更新权重分(公共)-D3统计更新执行进度(入参进度值)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(),"D3执行部门指标自动更新权重分(公共)-D3统计更新执行进度(入参进度值)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;



    }
ImplementDeptObjAutoUpdateWeightScoreComRespDto retData = new ImplementDeptObjAutoUpdateWeightScoreComRespDto();





return retData;
  }
/**
   * D3执行高层下发自动更新权重分(公共)[7247]
   * gen by moon at 6/26/2023, 6:52:06 AM
   */
  @Trace(operationName = "D3执行高层下发自动更新权重分(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTopIssueAutoUpdateWeightScoreComRespDto implementTopIssueAutoUpdateWeightScoreCom(ImplementTopIssueAutoUpdateWeightScoreComReqDto reqDto){


      //步骤0: M3执行接收字段入参（特殊方法） - implementAcceptField
     //ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1062427_1
receptionServiceReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1062425_1
receptionServiceReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1062428_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1062426_1
    }

    /*M3接收字段入参[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getExecuteProgressValue(),"D3执行高层下发自动更新权重分(公共)-M3接收字段入参-执行进度值不能为空",false);
Assert.isNull(receptionServiceReq.getObjectId(),"D3执行高层下发自动更新权重分(公共)-M3接收字段入参-归属对象内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getUseTypeCode(),"D3执行高层下发自动更新权重分(公共)-M3接收字段入参-用途类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3执行高层下发自动更新权重分(公共)-M3接收字段入参-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbWeightTarget.implementAcceptField(receptionServiceReq);




//步骤1: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1062402_1
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1062403_1
queryEvaObjTargetCycleDetailReq.setTargetCycleContentTypeCode("TARGET");//sourceId:1062404_1
queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:1062405_1
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1062407_1
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1062406_1
    }

    /*3-3-09查目标的目标父周期ID[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3执行高层下发自动更新权重分(公共)-3-3-09查目标的目标父周期ID-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3执行高层下发自动更新权重分(公共)-3-3-09查目标的目标父周期ID-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentTypeCode(),"D3执行高层下发自动更新权重分(公共)-3-3-09查目标的目标父周期ID-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3执行高层下发自动更新权重分(公共)-3-3-09查目标的目标父周期ID-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3执行高层下发自动更新权重分(公共)-3-3-09查目标的目标父周期ID-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3执行高层下发自动更新权重分(公共)-3-3-09查目标的目标父周期ID-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤2: D3执行自动更新权重分(公共) - implementAutoUpdateWeightScoreCom
     ImplementAutoUpdateWeightScoreComRespDto implementAutoUpdateWeightScoreComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementAutoUpdateWeightScoreComReqDto implementAutoUpdateWeightScoreComReqDto=new ImplementAutoUpdateWeightScoreComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      implementAutoUpdateWeightScoreComReqDto.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1062032_1
    }
if(reqDto!=null){
      implementAutoUpdateWeightScoreComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1062030_1
implementAutoUpdateWeightScoreComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1062033_1
implementAutoUpdateWeightScoreComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1062034_1
implementAutoUpdateWeightScoreComReqDto.setComFloatField(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1062031_1
    }

    /*D3执行自动更新权重分(公共)[5523]   */
    Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getEvaObjTargetCycleId(),"D3执行高层下发自动更新权重分(公共)-D3执行自动更新权重分(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getEvaluationTemplateId(),"D3执行高层下发自动更新权重分(公共)-D3执行自动更新权重分(公共)-评价模板ID不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getObjectId(),"D3执行高层下发自动更新权重分(公共)-D3执行自动更新权重分(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getUseTypeCode(),"D3执行高层下发自动更新权重分(公共)-D3执行自动更新权重分(公共)-用途类型编码不能为空",false);
Assert.isNull(implementAutoUpdateWeightScoreComReqDto.getComFloatField(),"D3执行高层下发自动更新权重分(公共)-D3执行自动更新权重分(公共)-通用数值字段（小数型）不能为空",false);
      implementAutoUpdateWeightScoreComRespDto = targetCycleService.implementAutoUpdateWeightScoreCom(implementAutoUpdateWeightScoreComReqDto)/*vcase invoke isSameApp*/;



           }

ImplementTopIssueAutoUpdateWeightScoreComRespDto retData = new ImplementTopIssueAutoUpdateWeightScoreComRespDto();





return retData;
  }
/**
   * D3执行自动计算平均权重(公共)[7578]
   * gen by moon at 2/22/2024, 9:24:10 PM
   */
  @Trace(operationName = "D3执行自动计算平均权重(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAutoCountAverageWeightComRespDto implementAutoCountAverageWeightCom(ImplementAutoCountAverageWeightComReqDto reqDto){


      //virtualUsage 3-3-09查上级目标父周期  50623
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:1193979_1_50623
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1193981_1_50623
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1193976_1_50623
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1193982_1_50623
queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1193978_1_50623
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1193980_1_50623
    }

    /*3-3-09查上级目标父周期[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标父周期-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标父周期-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标父周期-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标父周期-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标父周期-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage M3约定权重父子中周期类型为父周期  50733
      //ModelCode: receptionService
        ImplementGainInParameterFieldsRespDto receptionServiceRes = null;
    ImplementGainInParameterFieldsReqDto receptionServiceReq=new ImplementGainInParameterFieldsReqDto();
  receptionServiceReq.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1196823_1_50733

    /*M3约定权重父子中周期类型为父周期[6965]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-M3约定权重父子中周期类型为父周期-父子中周期类型不能为空",false);
      receptionServiceRes = nbWeightTarget.implementGainInParameterFields(receptionServiceReq);



//virtualUsage 3-3-09-02查上级目标周期权重  50624
      OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryEvaObjTargetCycleWeightDetailReq queryEvaObjTargetCycleWeightDetailReq=new QueryEvaObjTargetCycleWeightDetailReq();
  queryEvaObjTargetCycleWeightDetailReq.setIsArchive("FALSE");//sourceId:1194020_1_50624
if(omsEvaluationObjectTargetCycle!=null){
      queryEvaObjTargetCycleWeightDetailReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1194017_1_50624
    }
if(receptionServiceRes!=null){
      queryEvaObjTargetCycleWeightDetailReq.setParentSubMidCycleType(receptionServiceRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1196926_1_50624
    }
if(reqDto!=null){
      queryEvaObjTargetCycleWeightDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194019_1_50624
    }

    /*3-3-09-02查上级目标周期权重[2649]   */
    Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getEvaObjTargetCycleId(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-父子中周期类型不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-是否存档不能为空",false);
      omsEvaObjTargetCycleWeightSet = mOmsEvaObjTargetCycleWeightSetService.queryEvaObjTargetCycleWeightDetail(queryEvaObjTargetCycleWeightDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("SINGLE_CYCLE")||reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("IRREGULAR_CYCLE")||reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE"))) {
        //if((D3执行自动计算平均权重(公共).周期模式类型编码 等于 单周期 or D3执行自动计算平均权重(公共).周期模式类型编码 等于 不规则周期 or D3执行自动计算平均权重(公共).周期模式类型编码 等于 父子周期))  50625

List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    if(omsEvaluationObjectTargetCycle !=null){
          QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1194056_1_50626
if(omsEvaluationObjectTargetCycle!=null){
      queryEvaObjTargetCycleListReq.setParentEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1194051_1_50626
queryEvaObjTargetCycleListReq.setIsParentCycle(omsEvaluationObjectTargetCycle.getIsParentCycle());//SimpleFieldAssign//sourceId:1194054_1_50626
    }
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1194052_1_50626
queryEvaObjTargetCycleListReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1194053_1_50626
queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194055_1_50626
    }

    /*3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getParentEvaObjTargetCycleId(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-上级被评对象目标周期标识不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTypeCode(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet =new ArrayList<>();
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          BatchQueryEvaObjTargetCycleWeightListReq batchQueryEvaObjTargetCycleWeightListReq=new BatchQueryEvaObjTargetCycleWeightListReq();
  batchQueryEvaObjTargetCycleWeightListReq.setIsArchive("FALSE");//sourceId:1194063_1_50628
if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      batchQueryEvaObjTargetCycleWeightListReq.setEvaObjTargetCycleWeightList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1194061_1_50628
    }
if(receptionServiceRes!=null){
      batchQueryEvaObjTargetCycleWeightListReq.setParentSubMidCycleType(receptionServiceRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1196739_1_50628
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleWeightListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194065_1_50628
    }

    /*3-3-09-02批量查下级目标周期权重列表[2247]   */
    Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-父子中周期类型不能为空",false);
    Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-是否存档不能为空",false);
      listOmsEvaObjTargetCycleWeightSet = mOmsEvaObjTargetCycleWeightSetService.batchQueryEvaObjTargetCycleWeightList(batchQueryEvaObjTargetCycleWeightListReq)/*vcase invoke 本地 method 方法调用;*/;



           }
ImplementAnalyseSubWeightComRespDto implementAnalyseSubWeightComRespDto = null;
    if(listOmsEvaObjTargetCycleWeightSet !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)&& listOmsEvaObjTargetCycleWeightSet.size()>0 ){
          ImplementAnalyseSubWeightComReqDto implementAnalyseSubWeightComReqDto=new ImplementAnalyseSubWeightComReqDto();
  if(listOmsEvaObjTargetCycleWeightSet!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)&&  listOmsEvaObjTargetCycleWeightSet !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)){
      implementAnalyseSubWeightComReqDto.setEvaObjTargetCycleWeightList(listOmsEvaObjTargetCycleWeightSet.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1558075_1_61632
    }
if(reqDto!=null){
      implementAnalyseSubWeightComReqDto.setWeightDecimalPoint(Long.valueOf(reqDto.getWeightPoint()));//SimpleFieldAssign//sourceId:1558076_1_61632
implementAnalyseSubWeightComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1558077_1_61632
    }

    /*D3执行分析下级权重(公共)[8521]   */
    Assert.isNull(implementAnalyseSubWeightComReqDto.getWeightDecimalPoint(),"D3执行自动计算平均权重(公共)-D3执行分析下级权重(公共)-权重小数点规则不能为空",false);
Assert.isNull(implementAnalyseSubWeightComReqDto.getDecimalDigitsLastRules(),"D3执行自动计算平均权重(公共)-D3执行分析下级权重(公共)-小数最后一位规则不能为空",false);
      implementAnalyseSubWeightComRespDto = implementAnalyseSubWeightCom(implementAnalyseSubWeightComReqDto)/*vcase invoke 同服务,同domain*/;



           }
if((listOmsEvaObjTargetCycleWeightSet!= null&&  listOmsEvaObjTargetCycleWeightSet !=null && listOmsEvaObjTargetCycleWeightSet.size()>0&&implementAnalyseSubWeightComRespDto!= null&& implementAnalyseSubWeightComRespDto.getWeightValue() != null )) {
        //if((3-3-09-02批量查下级目标父周期权重列表.被评对象目标周期权重列表数据集条数 大于 0 and D3执行分析下级父周期权重(公共).权重 值不等于空 ))  50631

boolean bOOLEAN ;
    if(listOmsEvaObjTargetCycleWeightSet !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)&& listOmsEvaObjTargetCycleWeightSet.size()>0 &&implementAnalyseSubWeightComRespDto !=null){
          List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet_2=new ArrayList<>();
  if(listOmsEvaObjTargetCycleWeightSet!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)&&  listOmsEvaObjTargetCycleWeightSet !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)){
      ImplementAnalyseSubWeightComRespDto finalImplementAnalyseSubWeightComRespDto = implementAnalyseSubWeightComRespDto;
      listOmsEvaObjTargetCycleWeightSet_2 = //objList-to-objLists
        listOmsEvaObjTargetCycleWeightSet.stream().map(item -> {
      OmsEvaObjTargetCycleWeightSet elm = new OmsEvaObjTargetCycleWeightSet();
      elm.setObjTargetCycleWeightSetId(item.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:247442_2_50632
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:247445_2_50632
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:247446_2_50632
if(finalImplementAnalyseSubWeightComRespDto !=null){
      elm.setWeightValue(finalImplementAnalyseSubWeightComRespDto.getWeightValue());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:247443_2_50632
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1194109_1_50632
    }

    /*3-3-09-02批量改被评对象目标周期权重[3676]   */

      bOOLEAN = mOmsEvaObjTargetCycleWeightSetService.batchUpdateEvaObjTargetCycleWeight(listOmsEvaObjTargetCycleWeightSet_2)/*vcase invoke 本地 method 方法调用;*/;



           }
if((implementAnalyseSubWeightComRespDto!= null&& implementAnalyseSubWeightComRespDto.getObjTargetCycleWeightSetId() != null )) {
        //if(D3执行分析下级权重(公共).最大对象目标周期权重设置ID 值不等于空 )  61633

boolean bOOLEAN_1 ;
    if(implementAnalyseSubWeightComRespDto !=null){
          OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet_2=new OmsEvaObjTargetCycleWeightSet();
  omsEvaObjTargetCycleWeightSet_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1558098_1_61634
omsEvaObjTargetCycleWeightSet_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1558099_1_61634
if(implementAnalyseSubWeightComRespDto!=null){
      omsEvaObjTargetCycleWeightSet_2.setObjTargetCycleWeightSetId(implementAnalyseSubWeightComRespDto.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:1558096_1_61634
omsEvaObjTargetCycleWeightSet_2.setWeightValue(implementAnalyseSubWeightComRespDto.getMaxWeightValue());//SimpleFieldAssign//sourceId:1558097_1_61634
    }

    /*3-3-09-02修改被评对象目标周期权重[5084]   */
    Assert.isNull(omsEvaObjTargetCycleWeightSet_2.getObjTargetCycleWeightSetId(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-对象目标周期权重设置ID不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet_2.getWeightValue(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-权重不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet_2.getOperationInductionId(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet_2.getOperateTime(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-操作时间不能为空",false);
      bOOLEAN_1 = mOmsEvaObjTargetCycleWeightSetService.updateEvaObjTargetCycleWeight(omsEvaObjTargetCycleWeightSet_2)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet_3 =new ArrayList<>();
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          BatchQueryEvaObjTargetCycleWeightListReq batchQueryEvaObjTargetCycleWeightListReq_1=new BatchQueryEvaObjTargetCycleWeightListReq();
  batchQueryEvaObjTargetCycleWeightListReq_1.setIsArchive("FALSE");//sourceId:1194063_1_61644
if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      batchQueryEvaObjTargetCycleWeightListReq_1.setEvaObjTargetCycleWeightList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1194061_1_61644
    }
if(receptionServiceRes!=null){
      batchQueryEvaObjTargetCycleWeightListReq_1.setParentSubMidCycleType(receptionServiceRes.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1196739_1_61644
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleWeightListReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194065_1_61644
    }

    /*3-3-09-02批量查下级目标周期权重列表[2247]   */
    Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_1.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-父子中周期类型不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_1.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_1.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-是否存档不能为空",false);
      listOmsEvaObjTargetCycleWeightSet_3 = mOmsEvaObjTargetCycleWeightSetService.batchQueryEvaObjTargetCycleWeightList(batchQueryEvaObjTargetCycleWeightListReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
ImplementAutoCountSubWeightScoreComRespDto implementAutoCountSubWeightScoreComRespDto = null;
    if(listOmsEvaObjTargetCycleWeightSet_3 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_3)&& listOmsEvaObjTargetCycleWeightSet_3.size()>0 &&omsEvaObjTargetCycleWeightSet !=null){
          ImplementAutoCountSubWeightScoreComReqDto implementAutoCountSubWeightScoreComReqDto=new ImplementAutoCountSubWeightScoreComReqDto();
  if(listOmsEvaObjTargetCycleWeightSet_3!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_3)&&  listOmsEvaObjTargetCycleWeightSet_3 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_3)){
      implementAutoCountSubWeightScoreComReqDto.setEvaObjTargetCycleWeightList(listOmsEvaObjTargetCycleWeightSet_3.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1558508_1_61643
    }
if(omsEvaObjTargetCycleWeightSet!=null){
      implementAutoCountSubWeightScoreComReqDto.setWeightScore(omsEvaObjTargetCycleWeightSet.getWeightScore());//SimpleFieldAssign//sourceId:1558509_1_61643
    }
if(reqDto!=null){
      implementAutoCountSubWeightScoreComReqDto.setWeightDecimalPoint(reqDto.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1558510_1_61643
implementAutoCountSubWeightScoreComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1558511_1_61643
    }

    /*D3执行自动计算下级权重分(公共)[8522]   */
    Assert.isNull(implementAutoCountSubWeightScoreComReqDto.getWeightScore(),"D3执行自动计算平均权重(公共)-D3执行自动计算下级权重分(公共)-权重分值不能为空",false);
Assert.isNull(implementAutoCountSubWeightScoreComReqDto.getWeightDecimalPoint(),"D3执行自动计算平均权重(公共)-D3执行自动计算下级权重分(公共)-权重分小数点规则   不能为空",false);
Assert.isNull(implementAutoCountSubWeightScoreComReqDto.getDecimalDigitsLastRules(),"D3执行自动计算平均权重(公共)-D3执行自动计算下级权重分(公共)-小数最后一位规则不能为空",false);
      implementAutoCountSubWeightScoreComRespDto = implementAutoCountSubWeightScoreCom(implementAutoCountSubWeightScoreComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      }
      }
else if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE")&&reqDto!= null&&  reqDto.getOpenMidCycle() !=null && reqDto.getOpenMidCycle().equals("TRUE"))){
       //elseif((D3执行自动计算平均权重(公共).周期模式类型编码 等于 父子周期 and D3执行自动计算平均权重(公共).是否开启中期 等于 是))  50633

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setIsMetaphase("TRUE");//sourceId:1194260_1_50651
queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:1194262_1_50651
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1194257_1_50651
queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1194258_1_50651
queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1194259_1_50651
queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194261_1_50651
    }

    /*3-3-09查上级目标中周期[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标中周期-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标中周期-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsMetaphase(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标中周期-是否中期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标中周期-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标中周期-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementGainInParameterFieldsRespDto receptionServiceRes_2 = null;
    ImplementGainInParameterFieldsReqDto receptionServiceReq_1=new ImplementGainInParameterFieldsReqDto();
  receptionServiceReq_1.setParentSubMidCycleType("MID_CYCLE");//sourceId:1196909_1_50732

    /*M3约定权重父子中周期类型为中周期[6965]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-M3约定权重父子中周期类型为中周期-父子中周期类型不能为空",false);
      receptionServiceRes_2 = nbWeightTarget.implementGainInParameterFields(receptionServiceReq_1);



OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet_3 = null;
    if(omsEvaluationObjectTargetCycle_2 !=null){
          QueryEvaObjTargetCycleWeightDetailReq queryEvaObjTargetCycleWeightDetailReq_1=new QueryEvaObjTargetCycleWeightDetailReq();
  queryEvaObjTargetCycleWeightDetailReq_1.setIsArchive("FALSE");//sourceId:1194020_1_50652
if(omsEvaluationObjectTargetCycle_2!=null){
      queryEvaObjTargetCycleWeightDetailReq_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1194017_1_50652
    }
if(receptionServiceRes_2!=null){
      queryEvaObjTargetCycleWeightDetailReq_1.setParentSubMidCycleType(receptionServiceRes_2.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1196926_1_50652
    }
if(reqDto!=null){
      queryEvaObjTargetCycleWeightDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194019_1_50652
    }

    /*3-3-09-02查上级目标周期权重[2649]   */
    Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_1.getEvaObjTargetCycleId(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_1.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-父子中周期类型不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_1.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_1.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-是否存档不能为空",false);
      omsEvaObjTargetCycleWeightSet_3 = mOmsEvaObjTargetCycleWeightSetService.queryEvaObjTargetCycleWeightDetail(queryEvaObjTargetCycleWeightDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_2 =new ArrayList<>();
    if(omsEvaluationObjectTargetCycle_2 !=null){
          QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq_1=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq_1.setIsArchive("FALSE");//sourceId:1194056_1_50653
if(omsEvaluationObjectTargetCycle_2!=null){
      queryEvaObjTargetCycleListReq_1.setParentEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1194051_1_50653
queryEvaObjTargetCycleListReq_1.setIsMetaphase(omsEvaluationObjectTargetCycle_2.getIsMetaphase());//SimpleFieldAssign//sourceId:1194266_1_50653
    }
if(reqDto!=null){
      queryEvaObjTargetCycleListReq_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1194052_1_50653
queryEvaObjTargetCycleListReq_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1194053_1_50653
queryEvaObjTargetCycleListReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194055_1_50653
    }

    /*3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq_1.getParentEvaObjTargetCycleId(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-上级被评对象目标周期标识不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq_1.getEvaObjTypeCode(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq_1.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq_1.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet_4 =new ArrayList<>();
    if(listOmsEvaluationObjectTargetCycle_2 !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_2)&& listOmsEvaluationObjectTargetCycle_2.size()>0 ){
          BatchQueryEvaObjTargetCycleWeightListReq batchQueryEvaObjTargetCycleWeightListReq_2=new BatchQueryEvaObjTargetCycleWeightListReq();
  batchQueryEvaObjTargetCycleWeightListReq_2.setIsArchive("FALSE");//sourceId:1194063_1_50654
if(listOmsEvaluationObjectTargetCycle_2!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_2)&&  listOmsEvaluationObjectTargetCycle_2 !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_2)){
      batchQueryEvaObjTargetCycleWeightListReq_2.setEvaObjTargetCycleWeightList(listOmsEvaluationObjectTargetCycle_2.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1194061_1_50654
    }
if(receptionServiceRes_2!=null){
      batchQueryEvaObjTargetCycleWeightListReq_2.setParentSubMidCycleType(receptionServiceRes_2.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1196739_1_50654
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleWeightListReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194065_1_50654
    }

    /*3-3-09-02批量查下级目标周期权重列表[2247]   */
    Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_2.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-父子中周期类型不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_2.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_2.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-是否存档不能为空",false);
      listOmsEvaObjTargetCycleWeightSet_4 = mOmsEvaObjTargetCycleWeightSetService.batchQueryEvaObjTargetCycleWeightList(batchQueryEvaObjTargetCycleWeightListReq_2)/*vcase invoke 本地 method 方法调用;*/;



           }
ImplementAnalyseSubWeightComRespDto implementAnalyseSubWeightComRespDto_2 = null;
    if(listOmsEvaObjTargetCycleWeightSet_4 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_4)&& listOmsEvaObjTargetCycleWeightSet_4.size()>0 ){
          ImplementAnalyseSubWeightComReqDto implementAnalyseSubWeightComReqDto_1=new ImplementAnalyseSubWeightComReqDto();
  if(listOmsEvaObjTargetCycleWeightSet_4!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_4)&&  listOmsEvaObjTargetCycleWeightSet_4 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_4)){
      implementAnalyseSubWeightComReqDto_1.setEvaObjTargetCycleWeightList(listOmsEvaObjTargetCycleWeightSet_4.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1558075_1_61645
    }
if(reqDto!=null){
      implementAnalyseSubWeightComReqDto_1.setWeightDecimalPoint(Long.valueOf(reqDto.getWeightPoint()));//SimpleFieldAssign//sourceId:1558076_1_61645
implementAnalyseSubWeightComReqDto_1.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1558077_1_61645
    }

    /*D3执行分析下级权重(公共)[8521]   */
    Assert.isNull(implementAnalyseSubWeightComReqDto_1.getWeightDecimalPoint(),"D3执行自动计算平均权重(公共)-D3执行分析下级权重(公共)-权重小数点规则不能为空",false);
Assert.isNull(implementAnalyseSubWeightComReqDto_1.getDecimalDigitsLastRules(),"D3执行自动计算平均权重(公共)-D3执行分析下级权重(公共)-小数最后一位规则不能为空",false);
      implementAnalyseSubWeightComRespDto_2 = implementAnalyseSubWeightCom(implementAnalyseSubWeightComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
if((listOmsEvaluationObjectTargetCycle_2!= null&&  listOmsEvaluationObjectTargetCycle_2 !=null && listOmsEvaluationObjectTargetCycle_2.size()>0&&implementAnalyseSubWeightComRespDto_2!= null&& implementAnalyseSubWeightComRespDto_2.getWeightValue() != null )) {
        //if((3-3-09查下级目标中周期列表（用于查下级内容目标周期权重设置）.被评对象目标周期列表数据集条数 大于 0 and D3执行分析下级中期权重(公共).权重 值不等于空 ))  50658

boolean bOOLEAN_2 ;
    if(listOmsEvaObjTargetCycleWeightSet_4 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_4)&& listOmsEvaObjTargetCycleWeightSet_4.size()>0 &&implementAnalyseSubWeightComRespDto_2 !=null){
          List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet_5=new ArrayList<>();
  if(listOmsEvaObjTargetCycleWeightSet_4!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_4)&&  listOmsEvaObjTargetCycleWeightSet_4 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_4)){
      ImplementAnalyseSubWeightComRespDto finalImplementAnalyseSubWeightComRespDto_ = implementAnalyseSubWeightComRespDto_2;
      listOmsEvaObjTargetCycleWeightSet_5 = //objList-to-objLists
        listOmsEvaObjTargetCycleWeightSet_4.stream().map(item -> {
      OmsEvaObjTargetCycleWeightSet elm = new OmsEvaObjTargetCycleWeightSet();
      elm.setObjTargetCycleWeightSetId(item.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:247442_2_50659
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:247445_2_50659
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:247446_2_50659
if(finalImplementAnalyseSubWeightComRespDto_ !=null){
      elm.setWeightValue(finalImplementAnalyseSubWeightComRespDto_.getWeightValue());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:247443_2_50659
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1194109_1_50659
    }

    /*3-3-09-02批量改被评对象目标周期权重[3676]   */

      bOOLEAN_2 = mOmsEvaObjTargetCycleWeightSetService.batchUpdateEvaObjTargetCycleWeight(listOmsEvaObjTargetCycleWeightSet_5)/*vcase invoke 本地 method 方法调用;*/;



           }
if((implementAnalyseSubWeightComRespDto_2!= null&& implementAnalyseSubWeightComRespDto_2.getObjTargetCycleWeightSetId() != null )) {
        //if(D3执行分析下级中期权重(公共).最大对象目标周期权重设置ID 值不等于空 )  61646

boolean bOOLEAN_3 ;
    if(implementAnalyseSubWeightComRespDto_2 !=null){
          OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet_4=new OmsEvaObjTargetCycleWeightSet();
  omsEvaObjTargetCycleWeightSet_4.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1558098_1_61647
omsEvaObjTargetCycleWeightSet_4.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1558099_1_61647
if(implementAnalyseSubWeightComRespDto_2!=null){
      omsEvaObjTargetCycleWeightSet_4.setObjTargetCycleWeightSetId(implementAnalyseSubWeightComRespDto_2.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:1558096_1_61647
omsEvaObjTargetCycleWeightSet_4.setWeightValue(implementAnalyseSubWeightComRespDto_2.getMaxWeightValue());//SimpleFieldAssign//sourceId:1558097_1_61647
    }

    /*3-3-09-02修改被评对象目标周期权重[5084]   */
    Assert.isNull(omsEvaObjTargetCycleWeightSet_4.getObjTargetCycleWeightSetId(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-对象目标周期权重设置ID不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet_4.getWeightValue(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-权重不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet_4.getOperationInductionId(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet_4.getOperateTime(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-操作时间不能为空",false);
      bOOLEAN_3 = mOmsEvaObjTargetCycleWeightSetService.updateEvaObjTargetCycleWeight(omsEvaObjTargetCycleWeightSet_4)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet_6 =new ArrayList<>();
    if(listOmsEvaluationObjectTargetCycle_2 !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_2)&& listOmsEvaluationObjectTargetCycle_2.size()>0 ){
          BatchQueryEvaObjTargetCycleWeightListReq batchQueryEvaObjTargetCycleWeightListReq_3=new BatchQueryEvaObjTargetCycleWeightListReq();
  batchQueryEvaObjTargetCycleWeightListReq_3.setIsArchive("FALSE");//sourceId:1194063_1_61648
if(listOmsEvaluationObjectTargetCycle_2!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_2)&&  listOmsEvaluationObjectTargetCycle_2 !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_2)){
      batchQueryEvaObjTargetCycleWeightListReq_3.setEvaObjTargetCycleWeightList(listOmsEvaluationObjectTargetCycle_2.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1194061_1_61648
    }
if(receptionServiceRes_2!=null){
      batchQueryEvaObjTargetCycleWeightListReq_3.setParentSubMidCycleType(receptionServiceRes_2.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1196739_1_61648
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleWeightListReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194065_1_61648
    }

    /*3-3-09-02批量查下级目标周期权重列表[2247]   */
    Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_3.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-父子中周期类型不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_3.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_3.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-是否存档不能为空",false);
      listOmsEvaObjTargetCycleWeightSet_6 = mOmsEvaObjTargetCycleWeightSetService.batchQueryEvaObjTargetCycleWeightList(batchQueryEvaObjTargetCycleWeightListReq_3)/*vcase invoke 本地 method 方法调用;*/;



           }
ImplementAutoCountSubWeightScoreComRespDto implementAutoCountSubWeightScoreComRespDto_1 = null;
    if(listOmsEvaObjTargetCycleWeightSet_6 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_6)&& listOmsEvaObjTargetCycleWeightSet_6.size()>0 &&omsEvaObjTargetCycleWeightSet_3 !=null){
          ImplementAutoCountSubWeightScoreComReqDto implementAutoCountSubWeightScoreComReqDto_1=new ImplementAutoCountSubWeightScoreComReqDto();
  if(listOmsEvaObjTargetCycleWeightSet_6!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_6)&&  listOmsEvaObjTargetCycleWeightSet_6 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_6)){
      implementAutoCountSubWeightScoreComReqDto_1.setEvaObjTargetCycleWeightList(listOmsEvaObjTargetCycleWeightSet_6.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1558508_1_61649
    }
if(omsEvaObjTargetCycleWeightSet_3!=null){
      implementAutoCountSubWeightScoreComReqDto_1.setWeightScore(omsEvaObjTargetCycleWeightSet_3.getWeightScore());//SimpleFieldAssign//sourceId:1558509_1_61649
    }
if(reqDto!=null){
      implementAutoCountSubWeightScoreComReqDto_1.setWeightDecimalPoint(reqDto.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1558510_1_61649
implementAutoCountSubWeightScoreComReqDto_1.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1558511_1_61649
    }

    /*D3执行自动计算下级权重分(公共)[8522]   */
    Assert.isNull(implementAutoCountSubWeightScoreComReqDto_1.getWeightScore(),"D3执行自动计算平均权重(公共)-D3执行自动计算下级权重分(公共)-权重分值不能为空",false);
Assert.isNull(implementAutoCountSubWeightScoreComReqDto_1.getWeightDecimalPoint(),"D3执行自动计算平均权重(公共)-D3执行自动计算下级权重分(公共)-权重分小数点规则   不能为空",false);
Assert.isNull(implementAutoCountSubWeightScoreComReqDto_1.getDecimalDigitsLastRules(),"D3执行自动计算平均权重(公共)-D3执行自动计算下级权重分(公共)-小数最后一位规则不能为空",false);
      implementAutoCountSubWeightScoreComRespDto_1 = implementAutoCountSubWeightScoreCom(implementAutoCountSubWeightScoreComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
      }
    }
if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE"))) {
        //if(D3执行自动计算平均权重(公共).周期模式类型编码 等于 父子周期)  50638

List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_3 =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq_2=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq_2.setIsSubCycle("TRUE");//sourceId:1194145_1_50639
queryEvaObjTargetCycleListReq_2.setIsArchive("FALSE");//sourceId:1194147_1_50639
if(reqDto!=null){
      queryEvaObjTargetCycleListReq_2.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1194142_1_50639
queryEvaObjTargetCycleListReq_2.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1194143_1_50639
queryEvaObjTargetCycleListReq_2.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1194144_1_50639
queryEvaObjTargetCycleListReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194146_1_50639
    }

    /*3-3-09查上级目标子周期列表（用于循环发牌查下级儿子数据集）[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq_2.getEvaObjTypeCode(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标子周期列表（用于循环发牌查下级儿子数据集）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq_2.getTargetCycleContentId(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标子周期列表（用于循环发牌查下级儿子数据集）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq_2.getIsSubCycle(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标子周期列表（用于循环发牌查下级儿子数据集）-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq_2.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标子周期列表（用于循环发牌查下级儿子数据集）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq_2.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09查上级目标子周期列表（用于循环发牌查下级儿子数据集）-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle_3 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq_2)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementGainInParameterFieldsRespDto receptionServiceRes_4 = null;
    ImplementGainInParameterFieldsReqDto receptionServiceReq_2=new ImplementGainInParameterFieldsReqDto();
  receptionServiceReq_2.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1197016_1_50734

    /*M3约定权重父子中周期类型为子周期[6965]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-M3约定权重父子中周期类型为子周期-父子中周期类型不能为空",false);
      receptionServiceRes_4 = nbWeightTarget.implementGainInParameterFields(receptionServiceReq_2);



//ModelCode: circulationCollections
        for (OmsEvaluationObjectTargetCycle circulationCollectionsRes: listOmsEvaluationObjectTargetCycle_3){

OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet_5 = null;
    QueryEvaObjTargetCycleWeightDetailReq queryEvaObjTargetCycleWeightDetailReq_2=new QueryEvaObjTargetCycleWeightDetailReq();
  queryEvaObjTargetCycleWeightDetailReq_2.setIsArchive("FALSE");//sourceId:1194020_1_50642
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleWeightDetailReq_2.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1194017_1_50642
    }
if(receptionServiceRes_4!=null){
      queryEvaObjTargetCycleWeightDetailReq_2.setParentSubMidCycleType(receptionServiceRes_4.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1196926_1_50642
    }
if(reqDto!=null){
      queryEvaObjTargetCycleWeightDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194019_1_50642
    }

    /*3-3-09-02查上级目标周期权重[2649]   */
    Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_2.getEvaObjTargetCycleId(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_2.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-父子中周期类型不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_2.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_2.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09-02查上级目标周期权重-是否存档不能为空",false);
      omsEvaObjTargetCycleWeightSet_5 = mOmsEvaObjTargetCycleWeightSetService.queryEvaObjTargetCycleWeightDetail(queryEvaObjTargetCycleWeightDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_5 =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq_3=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq_3.setIsArchive("FALSE");//sourceId:1194056_1_50643
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleListReq_3.setParentEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1194051_1_50643
queryEvaObjTargetCycleListReq_3.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1194178_1_50643
queryEvaObjTargetCycleListReq_3.setIsSubCycle(circulationCollectionsRes.getIsSubCycle());//SimpleFieldAssign//sourceId:1194179_1_50643
    }
if(reqDto!=null){
      queryEvaObjTargetCycleListReq_3.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1194052_1_50643
queryEvaObjTargetCycleListReq_3.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1194053_1_50643
queryEvaObjTargetCycleListReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194055_1_50643
    }

    /*3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq_3.getParentEvaObjTargetCycleId(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-上级被评对象目标周期标识不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq_3.getEvaObjTypeCode(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq_3.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq_3.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09查下级目标周期列表（用于查下级内容目标周期权重设置）-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle_5 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq_3)/*vcase invoke 本地 method 方法调用;*/;



List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet_7 =new ArrayList<>();
    if(listOmsEvaluationObjectTargetCycle_5 !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_5)&& listOmsEvaluationObjectTargetCycle_5.size()>0 ){
          BatchQueryEvaObjTargetCycleWeightListReq batchQueryEvaObjTargetCycleWeightListReq_4=new BatchQueryEvaObjTargetCycleWeightListReq();
  batchQueryEvaObjTargetCycleWeightListReq_4.setIsArchive("FALSE");//sourceId:1194063_1_50644
if(listOmsEvaluationObjectTargetCycle_5!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_5)&&  listOmsEvaluationObjectTargetCycle_5 !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_5)){
      batchQueryEvaObjTargetCycleWeightListReq_4.setEvaObjTargetCycleWeightList(listOmsEvaluationObjectTargetCycle_5.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1194061_1_50644
    }
if(receptionServiceRes_4!=null){
      batchQueryEvaObjTargetCycleWeightListReq_4.setParentSubMidCycleType(receptionServiceRes_4.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1196739_1_50644
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleWeightListReq_4.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194065_1_50644
    }

    /*3-3-09-02批量查下级目标周期权重列表[2247]   */
    Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_4.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-父子中周期类型不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_4.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_4.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-是否存档不能为空",false);
      listOmsEvaObjTargetCycleWeightSet_7 = mOmsEvaObjTargetCycleWeightSetService.batchQueryEvaObjTargetCycleWeightList(batchQueryEvaObjTargetCycleWeightListReq_4)/*vcase invoke 本地 method 方法调用;*/;



           }
ImplementAnalyseSubWeightComRespDto implementAnalyseSubWeightComRespDto_3 = null;
    if(listOmsEvaObjTargetCycleWeightSet_7 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_7)&& listOmsEvaObjTargetCycleWeightSet_7.size()>0 ){
          ImplementAnalyseSubWeightComReqDto implementAnalyseSubWeightComReqDto_2=new ImplementAnalyseSubWeightComReqDto();
  if(listOmsEvaObjTargetCycleWeightSet_7!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_7)&&  listOmsEvaObjTargetCycleWeightSet_7 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_7)){
      implementAnalyseSubWeightComReqDto_2.setEvaObjTargetCycleWeightList(listOmsEvaObjTargetCycleWeightSet_7.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1558075_1_61651
    }
if(reqDto!=null){
      implementAnalyseSubWeightComReqDto_2.setWeightDecimalPoint(Long.valueOf(reqDto.getWeightPoint()));//SimpleFieldAssign//sourceId:1558076_1_61651
implementAnalyseSubWeightComReqDto_2.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1558077_1_61651
    }

    /*D3执行分析下级权重(公共)[8521]   */
    Assert.isNull(implementAnalyseSubWeightComReqDto_2.getWeightDecimalPoint(),"D3执行自动计算平均权重(公共)-D3执行分析下级权重(公共)-权重小数点规则不能为空",false);
Assert.isNull(implementAnalyseSubWeightComReqDto_2.getDecimalDigitsLastRules(),"D3执行自动计算平均权重(公共)-D3执行分析下级权重(公共)-小数最后一位规则不能为空",false);
      implementAnalyseSubWeightComRespDto_3 = implementAnalyseSubWeightCom(implementAnalyseSubWeightComReqDto_2)/*vcase invoke 同服务,同domain*/;



           }
if((listOmsEvaluationObjectTargetCycle_5!= null&&  listOmsEvaluationObjectTargetCycle_5 !=null && listOmsEvaluationObjectTargetCycle_5.size()>0&&implementAnalyseSubWeightComRespDto_3!= null&& implementAnalyseSubWeightComRespDto_3.getWeightValue() != null )) {
        //if((3-3-09查下级目标子周期列表（用于查下级内容目标周期权重设置）.被评对象目标周期列表数据集条数 大于 0 and D3执行分析下级子周期权重(公共).权重 值不等于空 ))  50648

boolean bOOLEAN_4 ;
    if(listOmsEvaObjTargetCycleWeightSet_7 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_7)&& listOmsEvaObjTargetCycleWeightSet_7.size()>0 &&implementAnalyseSubWeightComRespDto_3 !=null){
          List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet_8=new ArrayList<>();
  if(listOmsEvaObjTargetCycleWeightSet_7!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_7)&&  listOmsEvaObjTargetCycleWeightSet_7 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_7)){
      ImplementAnalyseSubWeightComRespDto finalImplementAnalyseSubWeightComRespDto_ = implementAnalyseSubWeightComRespDto_3;
      listOmsEvaObjTargetCycleWeightSet_8 = //objList-to-objLists
        listOmsEvaObjTargetCycleWeightSet_7.stream().map(item -> {
      OmsEvaObjTargetCycleWeightSet elm = new OmsEvaObjTargetCycleWeightSet();
      elm.setObjTargetCycleWeightSetId(item.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:247442_2_50649
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:247445_2_50649
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:247446_2_50649
if(finalImplementAnalyseSubWeightComRespDto_ !=null){
      elm.setWeightValue(finalImplementAnalyseSubWeightComRespDto_.getWeightValue());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:247443_2_50649
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1194109_1_50649
    }

    /*3-3-09-02批量改被评对象目标周期权重[3676]   */

      bOOLEAN_4 = mOmsEvaObjTargetCycleWeightSetService.batchUpdateEvaObjTargetCycleWeight(listOmsEvaObjTargetCycleWeightSet_8)/*vcase invoke 本地 method 方法调用;*/;



           }
if((implementAnalyseSubWeightComRespDto_3!= null&& implementAnalyseSubWeightComRespDto_3.getObjTargetCycleWeightSetId() != null )) {
        //if(D3执行分析下级子周期权重(公共).最大对象目标周期权重设置ID 值不等于空 )  61652

boolean bOOLEAN_5 ;
    if(implementAnalyseSubWeightComRespDto_3 !=null){
          OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet_6=new OmsEvaObjTargetCycleWeightSet();
  omsEvaObjTargetCycleWeightSet_6.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1558098_1_61653
omsEvaObjTargetCycleWeightSet_6.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1558099_1_61653
if(implementAnalyseSubWeightComRespDto_3!=null){
      omsEvaObjTargetCycleWeightSet_6.setObjTargetCycleWeightSetId(implementAnalyseSubWeightComRespDto_3.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:1558096_1_61653
omsEvaObjTargetCycleWeightSet_6.setWeightValue(implementAnalyseSubWeightComRespDto_3.getMaxWeightValue());//SimpleFieldAssign//sourceId:1558097_1_61653
    }

    /*3-3-09-02修改被评对象目标周期权重[5084]   */
    Assert.isNull(omsEvaObjTargetCycleWeightSet_6.getObjTargetCycleWeightSetId(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-对象目标周期权重设置ID不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet_6.getWeightValue(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-权重不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet_6.getOperationInductionId(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet_6.getOperateTime(),"D3执行自动计算平均权重(公共)-3-3-09-02修改被评对象目标周期权重-操作时间不能为空",false);
      bOOLEAN_5 = mOmsEvaObjTargetCycleWeightSetService.updateEvaObjTargetCycleWeight(omsEvaObjTargetCycleWeightSet_6)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet_9 =new ArrayList<>();
    if(listOmsEvaluationObjectTargetCycle_5 !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_5)&& listOmsEvaluationObjectTargetCycle_5.size()>0 ){
          BatchQueryEvaObjTargetCycleWeightListReq batchQueryEvaObjTargetCycleWeightListReq_5=new BatchQueryEvaObjTargetCycleWeightListReq();
  batchQueryEvaObjTargetCycleWeightListReq_5.setIsArchive("FALSE");//sourceId:1194063_1_61654
if(listOmsEvaluationObjectTargetCycle_5!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_5)&&  listOmsEvaluationObjectTargetCycle_5 !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_5)){
      batchQueryEvaObjTargetCycleWeightListReq_5.setEvaObjTargetCycleWeightList(listOmsEvaluationObjectTargetCycle_5.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1194061_1_61654
    }
if(receptionServiceRes_4!=null){
      batchQueryEvaObjTargetCycleWeightListReq_5.setParentSubMidCycleType(receptionServiceRes_4.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1196739_1_61654
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleWeightListReq_5.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194065_1_61654
    }

    /*3-3-09-02批量查下级目标周期权重列表[2247]   */
    Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_5.getParentSubMidCycleType(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-父子中周期类型不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_5.getEvaluationTemplateId(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightListReq_5.getIsArchive(),"D3执行自动计算平均权重(公共)-3-3-09-02批量查下级目标周期权重列表-是否存档不能为空",false);
      listOmsEvaObjTargetCycleWeightSet_9 = mOmsEvaObjTargetCycleWeightSetService.batchQueryEvaObjTargetCycleWeightList(batchQueryEvaObjTargetCycleWeightListReq_5)/*vcase invoke 本地 method 方法调用;*/;



           }
ImplementAutoCountSubWeightScoreComRespDto implementAutoCountSubWeightScoreComRespDto_2 = null;
    if(listOmsEvaObjTargetCycleWeightSet_9 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_9)&& listOmsEvaObjTargetCycleWeightSet_9.size()>0 &&omsEvaObjTargetCycleWeightSet_5 !=null){
          ImplementAutoCountSubWeightScoreComReqDto implementAutoCountSubWeightScoreComReqDto_2=new ImplementAutoCountSubWeightScoreComReqDto();
  if(listOmsEvaObjTargetCycleWeightSet_9!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_9)&&  listOmsEvaObjTargetCycleWeightSet_9 !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_9)){
      implementAutoCountSubWeightScoreComReqDto_2.setEvaObjTargetCycleWeightList(listOmsEvaObjTargetCycleWeightSet_9.stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1558508_1_61655
    }
if(omsEvaObjTargetCycleWeightSet_5!=null){
      implementAutoCountSubWeightScoreComReqDto_2.setWeightScore(omsEvaObjTargetCycleWeightSet_5.getWeightScore());//SimpleFieldAssign//sourceId:1558509_1_61655
    }
if(reqDto!=null){
      implementAutoCountSubWeightScoreComReqDto_2.setWeightDecimalPoint(reqDto.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1558510_1_61655
implementAutoCountSubWeightScoreComReqDto_2.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1558511_1_61655
    }

    /*D3执行自动计算下级权重分(公共)[8522]   */
    Assert.isNull(implementAutoCountSubWeightScoreComReqDto_2.getWeightScore(),"D3执行自动计算平均权重(公共)-D3执行自动计算下级权重分(公共)-权重分值不能为空",false);
Assert.isNull(implementAutoCountSubWeightScoreComReqDto_2.getWeightDecimalPoint(),"D3执行自动计算平均权重(公共)-D3执行自动计算下级权重分(公共)-权重分小数点规则   不能为空",false);
Assert.isNull(implementAutoCountSubWeightScoreComReqDto_2.getDecimalDigitsLastRules(),"D3执行自动计算平均权重(公共)-D3执行自动计算下级权重分(公共)-小数最后一位规则不能为空",false);
      implementAutoCountSubWeightScoreComRespDto_2 = implementAutoCountSubWeightScoreCom(implementAutoCountSubWeightScoreComReqDto_2)/*vcase invoke 同服务,同domain*/;



           }
      }
//ModelCode: circulationEnd
        }

      }
ImplementAutoCountAverageWeightComRespDto retData = new ImplementAutoCountAverageWeightComRespDto();





return retData;
  }
/**
   * D3执行自动计算评价对象树平均权重(公共)[7582]
   * gen by moon at 10/21/2023, 10:45:58 PM
   */
  @Trace(operationName = "D3执行自动计算评价对象树平均权重(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAutoCountEvaObjectAverageWeightComRespDto implementAutoCountEvaObjectAverageWeightCom(ImplementAutoCountEvaObjectAverageWeightComReqDto reqDto){


      //virtualUsage 3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）  50800
List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryTargetCycleCodeOrderStoMaxListReq queryTargetCycleCodeOrderStoMaxListReq=new QueryTargetCycleCodeOrderStoMaxListReq();
  queryTargetCycleCodeOrderStoMaxListReq.setEvaObjTargetCycleCode("1001");//CUSTOM_CONVENTION//sourceId:1194519_1_50800
queryTargetCycleCodeOrderStoMaxListReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1194521_1_50800
queryTargetCycleCodeOrderStoMaxListReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1194522_1_50800
queryTargetCycleCodeOrderStoMaxListReq.setIsParentCycle("TRUE");//sourceId:1194524_1_50800
queryTargetCycleCodeOrderStoMaxListReq.setIsArchive("FALSE");//sourceId:1194526_1_50800
queryTargetCycleCodeOrderStoMaxListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1194528_1_50800
if(reqDto!=null){
      queryTargetCycleCodeOrderStoMaxListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194525_1_50800
    }

    /*3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）[7584]   */
    Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaObjTargetCycleCode(),"D3执行自动计算评价对象树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-被评对象目标周期标识不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaObjEntityId(),"D3执行自动计算评价对象树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaObjTypeCode(),"D3执行自动计算评价对象树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-被评对象类型编码不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getIsParentCycle(),"D3执行自动计算评价对象树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-是否父周期不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaluationTemplateId(),"D3执行自动计算评价对象树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getIsArchive(),"D3执行自动计算评价对象树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-是否存档不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getSpaceId(),"D3执行自动计算评价对象树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-创建于空间ID不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryTargetCycleCodeOrderStoMaxList(queryTargetCycleCodeOrderStoMaxListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsEvaluationObjectTargetCycle!= null&&  listOmsEvaluationObjectTargetCycle !=null && listOmsEvaluationObjectTargetCycle.size()>0)) {
        //if(3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）.被评对象目标周期列表数据集条数 大于 0)  50801

ImplementCountDataSingleProgressComRespDto implementCountDataSingleProgressComRespDto = null;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          ImplementCountDataSingleProgressComReqDto implementCountDataSingleProgressComReqDto=new ImplementCountDataSingleProgressComReqDto();
  if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      implementCountDataSingleProgressComReqDto.setCountNumberDataSetsList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1199148_1_50814
    }
if(reqDto!=null){
      implementCountDataSingleProgressComReqDto.setCalcPara1(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1199150_1_50814
    }

    /*D3执行统计数据集单条进度值(公共)[6561]   */
    Assert.isNull(implementCountDataSingleProgressComReqDto.getCalcPara1(),"D3执行自动计算评价对象树平均权重(公共)-D3执行统计数据集单条进度值(公共)-被除数值不能为空",false);
      implementCountDataSingleProgressComRespDto = progressPublicTechnicaCapacityService.implementCountDataSingleProgressCom(implementCountDataSingleProgressComReqDto)/*vcase invoke isSameApp*/;



           }
//ModelCode: circulationCollections
        for (OmsEvaluationObjectTargetCycle circulationCollectionsRes: listOmsEvaluationObjectTargetCycle){

ImplementAutoCountAverageWeightComRespDto implementAutoCountAverageWeightComRespDto = null;
    ImplementAutoCountAverageWeightComReqDto implementAutoCountAverageWeightComReqDto=new ImplementAutoCountAverageWeightComReqDto();
  if(circulationCollectionsRes!=null){
      implementAutoCountAverageWeightComReqDto.setEvaObjEntityId(circulationCollectionsRes.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1194902_1_50804
implementAutoCountAverageWeightComReqDto.setEvaObjTypeCode(circulationCollectionsRes.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1194903_1_50804
implementAutoCountAverageWeightComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1194904_1_50804
    }
if(reqDto!=null){
      implementAutoCountAverageWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1194905_1_50804
implementAutoCountAverageWeightComReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1194906_1_50804
implementAutoCountAverageWeightComReqDto.setOpenMidCycle(reqDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1194907_1_50804
implementAutoCountAverageWeightComReqDto.setWeightPoint(reqDto.getWeightPoint());//SimpleFieldAssign//sourceId:1199112_1_50804
implementAutoCountAverageWeightComReqDto.setWeightDecimalPoint(reqDto.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1199113_1_50804
implementAutoCountAverageWeightComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1194908_1_50804
    }

    /*D3执行自动计算平均权重(公共)[7578]   */
    Assert.isNull(implementAutoCountAverageWeightComReqDto.getEvaObjEntityId(),"D3执行自动计算评价对象树平均权重(公共)-D3执行自动计算平均权重(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getEvaObjTypeCode(),"D3执行自动计算评价对象树平均权重(公共)-D3执行自动计算平均权重(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getTargetCycleContentId(),"D3执行自动计算评价对象树平均权重(公共)-D3执行自动计算平均权重(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getEvaluationTemplateId(),"D3执行自动计算评价对象树平均权重(公共)-D3执行自动计算平均权重(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getPeriodicModeTypeCode(),"D3执行自动计算评价对象树平均权重(公共)-D3执行自动计算平均权重(公共)-周期模式类型编码不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getWeightPoint(),"D3执行自动计算评价对象树平均权重(公共)-D3执行自动计算平均权重(公共)-权重小数点规则不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getWeightDecimalPoint(),"D3执行自动计算评价对象树平均权重(公共)-D3执行自动计算平均权重(公共)-权重分小数点规则   不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getDecimalDigitsLastRules(),"D3执行自动计算评价对象树平均权重(公共)-D3执行自动计算平均权重(公共)-小数最后一位规则不能为空",false);
      implementAutoCountAverageWeightComRespDto = implementAutoCountAverageWeightCom(implementAutoCountAverageWeightComReqDto)/*vcase invoke 同服务,同domain*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
    if(implementCountDataSingleProgressComRespDto !=null){
          ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  if(implementCountDataSingleProgressComRespDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(implementCountDataSingleProgressComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1199140_1_50815
    }
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1199142_1_50815
implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1199143_1_50815
implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1199144_1_50815
    }

    /*D3更新执行进度(公共)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(),"D3执行自动计算评价对象树平均权重(公共)-D3更新执行进度(公共)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(),"D3执行自动计算评价对象树平均权重(公共)-D3更新执行进度(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(),"D3执行自动计算评价对象树平均权重(公共)-D3更新执行进度(公共)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(),"D3执行自动计算评价对象树平均权重(公共)-D3更新执行进度(公共)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;



           }
//ModelCode: circulationEnd
        }

      }
ImplementAutoCountEvaObjectAverageWeightComRespDto retData = new ImplementAutoCountEvaObjectAverageWeightComRespDto();





return retData;
  }
/**
   * D3执行自定动计算部门任务书树平均权重(公共)[7583]
   * gen by moon at 10/21/2023, 10:46:05 PM
   */
  @Trace(operationName = "D3执行自定动计算部门任务书树平均权重(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAutoCountDeptTaskAverageWeightComRespDto implementAutoCountDeptTaskAverageWeightCom(ImplementAutoCountDeptTaskAverageWeightComReqDto reqDto){


      //virtualUsage 3-3-09-03查评价模板部门目标任务书根节点列表  50783
      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setEvaObjTypeCode("FLEVEL_OBJ_TASK_DUTY_DEPT");//sourceId:1198957_1_50783
queryEvaObjTargetCycleListReq.setTargetCycleContentTypeCode("TARGET");//sourceId:1198958_1_50783
queryEvaObjTargetCycleListReq.setIsParentCycle("TRUE");//sourceId:1198959_1_50783
queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1198961_1_50783
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1198960_1_50783
    }

    /*3-3-09-03查评价模板部门目标任务书根节点列表[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTypeCode(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09-03查评价模板部门目标任务书根节点列表-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentTypeCode(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09-03查评价模板部门目标任务书根节点列表-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsParentCycle(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09-03查评价模板部门目标任务书根节点列表-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09-03查评价模板部门目标任务书根节点列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09-03查评价模板部门目标任务书根节点列表-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsEvaluationObjectTargetCycle!= null&&  listOmsEvaluationObjectTargetCycle !=null && listOmsEvaluationObjectTargetCycle.size()>0)) {
        //if(3-3-09-03查评价模板部门目标任务书根节点列表.被评对象目标周期列表数据集条数 大于 0)  50703

ImplementCountDataSingleProgressComRespDto implementCountDataSingleProgressComRespDto = null;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          ImplementCountDataSingleProgressComReqDto implementCountDataSingleProgressComReqDto=new ImplementCountDataSingleProgressComReqDto();
  if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      implementCountDataSingleProgressComReqDto.setCountNumberDataSetsList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1199160_1_50816
    }
if(reqDto!=null){
      implementCountDataSingleProgressComReqDto.setCalcPara1(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1199162_1_50816
    }

    /*D3计算数据集单条进度值(公共)[6561]   */
    Assert.isNull(implementCountDataSingleProgressComReqDto.getCalcPara1(),"D3执行自定动计算部门任务书树平均权重(公共)-D3计算数据集单条进度值(公共)-被除数值不能为空",false);
      implementCountDataSingleProgressComRespDto = progressPublicTechnicaCapacityService.implementCountDataSingleProgressCom(implementCountDataSingleProgressComReqDto)/*vcase invoke isSameApp*/;



           }
//ModelCode: circulationCollections
        for (OmsEvaluationObjectTargetCycle circulationCollectionsRes: listOmsEvaluationObjectTargetCycle){

List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_2 =new ArrayList<>();
          QueryTargetCycleCodeOrderStoMaxListReq queryTargetCycleCodeOrderStoMaxListReq=new QueryTargetCycleCodeOrderStoMaxListReq();
  queryTargetCycleCodeOrderStoMaxListReq.setIsParentCycle("TRUE");//sourceId:1196278_1_50805
queryTargetCycleCodeOrderStoMaxListReq.setIsArchive("FALSE");//sourceId:1196280_1_50805
queryTargetCycleCodeOrderStoMaxListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1196281_1_50805
if(circulationCollectionsRes!=null){
      queryTargetCycleCodeOrderStoMaxListReq.setEvaObjTargetCycleCode(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1196273_1_50805
queryTargetCycleCodeOrderStoMaxListReq.setEvaObjEntityId(circulationCollectionsRes.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1196275_1_50805
queryTargetCycleCodeOrderStoMaxListReq.setEvaObjTypeCode(circulationCollectionsRes.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1196276_1_50805
    }
if(reqDto!=null){
      queryTargetCycleCodeOrderStoMaxListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1196279_1_50805
    }

    /*3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）[7584]   */
    Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaObjTargetCycleCode(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-被评对象目标周期标识不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaObjEntityId(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaObjTypeCode(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-被评对象类型编码不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getIsParentCycle(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-是否父周期不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getEvaluationTemplateId(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getIsArchive(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-是否存档不能为空",false);
Assert.isNull(queryTargetCycleCodeOrderStoMaxListReq.getSpaceId(),"D3执行自定动计算部门任务书树平均权重(公共)-3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）-创建于空间ID不能为空",false);
      listOmsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryTargetCycleCodeOrderStoMaxList(queryTargetCycleCodeOrderStoMaxListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsEvaluationObjectTargetCycle_2!= null&&  listOmsEvaluationObjectTargetCycle_2 !=null && listOmsEvaluationObjectTargetCycle_2.size()>0)) {
        //if(3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）.被评对象目标周期列表数据集条数 大于 0)  50806

ImplementCountDataSingleProgressComRespDto implementCountDataSingleProgressComRespDto_2 = null;
    if(listOmsEvaluationObjectTargetCycle_2 !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_2)&& listOmsEvaluationObjectTargetCycle_2.size()>0 &&implementCountDataSingleProgressComRespDto !=null){
          ImplementCountDataSingleProgressComReqDto implementCountDataSingleProgressComReqDto_1=new ImplementCountDataSingleProgressComReqDto();
  if(listOmsEvaluationObjectTargetCycle_2!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_2)&&  listOmsEvaluationObjectTargetCycle_2 !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_2)){
      implementCountDataSingleProgressComReqDto_1.setCountNumberDataSetsList(listOmsEvaluationObjectTargetCycle_2.stream().map(item->item.getTargetCycleContentId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1199160_1_50817
    }
if(implementCountDataSingleProgressComRespDto!=null){
      implementCountDataSingleProgressComReqDto_1.setCalcPara1(implementCountDataSingleProgressComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1199162_1_50817
    }

    /*D3计算数据集单条进度值(公共)[6561]   */
    Assert.isNull(implementCountDataSingleProgressComReqDto_1.getCalcPara1(),"D3执行自定动计算部门任务书树平均权重(公共)-D3计算数据集单条进度值(公共)-被除数值不能为空",false);
      implementCountDataSingleProgressComRespDto_2 = progressPublicTechnicaCapacityService.implementCountDataSingleProgressCom(implementCountDataSingleProgressComReqDto_1)/*vcase invoke isSameApp*/;



           }
//ModelCode: circulationCollections
        for (OmsEvaluationObjectTargetCycle circulationCollectionsRes_2: listOmsEvaluationObjectTargetCycle_2){

ImplementAutoCountAverageWeightComRespDto implementAutoCountAverageWeightComRespDto = null;
    ImplementAutoCountAverageWeightComReqDto implementAutoCountAverageWeightComReqDto=new ImplementAutoCountAverageWeightComReqDto();
  if(circulationCollectionsRes_2!=null){
      implementAutoCountAverageWeightComReqDto.setEvaObjEntityId(circulationCollectionsRes_2.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1196315_1_50809
implementAutoCountAverageWeightComReqDto.setEvaObjTypeCode(circulationCollectionsRes_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1196316_1_50809
implementAutoCountAverageWeightComReqDto.setTargetCycleContentId(circulationCollectionsRes_2.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1196317_1_50809
    }
if(reqDto!=null){
      implementAutoCountAverageWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1196318_1_50809
implementAutoCountAverageWeightComReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1196319_1_50809
implementAutoCountAverageWeightComReqDto.setOpenMidCycle(reqDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1196320_1_50809
implementAutoCountAverageWeightComReqDto.setWeightPoint(reqDto.getWeightPoint());//SimpleFieldAssign//sourceId:1199120_1_50809
implementAutoCountAverageWeightComReqDto.setWeightDecimalPoint(reqDto.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1199121_1_50809
implementAutoCountAverageWeightComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1196321_1_50809
    }

    /*D3执行自动计算平均权重(公共)[7578]   */
    Assert.isNull(implementAutoCountAverageWeightComReqDto.getEvaObjEntityId(),"D3执行自定动计算部门任务书树平均权重(公共)-D3执行自动计算平均权重(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getEvaObjTypeCode(),"D3执行自定动计算部门任务书树平均权重(公共)-D3执行自动计算平均权重(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getTargetCycleContentId(),"D3执行自定动计算部门任务书树平均权重(公共)-D3执行自动计算平均权重(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getEvaluationTemplateId(),"D3执行自定动计算部门任务书树平均权重(公共)-D3执行自动计算平均权重(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getPeriodicModeTypeCode(),"D3执行自定动计算部门任务书树平均权重(公共)-D3执行自动计算平均权重(公共)-周期模式类型编码不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getWeightPoint(),"D3执行自定动计算部门任务书树平均权重(公共)-D3执行自动计算平均权重(公共)-权重小数点规则不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getWeightDecimalPoint(),"D3执行自定动计算部门任务书树平均权重(公共)-D3执行自动计算平均权重(公共)-权重分小数点规则   不能为空",false);
Assert.isNull(implementAutoCountAverageWeightComReqDto.getDecimalDigitsLastRules(),"D3执行自定动计算部门任务书树平均权重(公共)-D3执行自动计算平均权重(公共)-小数最后一位规则不能为空",false);
      implementAutoCountAverageWeightComRespDto = implementAutoCountAverageWeightCom(implementAutoCountAverageWeightComReqDto)/*vcase invoke 同服务,同domain*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
    if(implementCountDataSingleProgressComRespDto_2 !=null){
          ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  if(implementCountDataSingleProgressComRespDto_2!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(implementCountDataSingleProgressComRespDto_2.getCalcResult());//SimpleFieldAssign//sourceId:1199163_1_50818
    }
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1199165_1_50818
implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1199166_1_50818
implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1199167_1_50818
    }

    /*D3更新执行进度(公共)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;



           }
//ModelCode: circulationEnd
        }

      }
else if((listOmsEvaluationObjectTargetCycle_2!= null&&  listOmsEvaluationObjectTargetCycle_2 !=null && listOmsEvaluationObjectTargetCycle_2.size()==0)){
       //elseif(3-3-09右模糊查目标父周期（标识排序小到大）列表（包含自己）.被评对象目标周期列表数据集条数 等于 0)  50819

ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_1 = null;
    if(implementCountDataSingleProgressComRespDto !=null){
          ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_1=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  if(implementCountDataSingleProgressComRespDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_1.setExecuteProgressValue(implementCountDataSingleProgressComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1199163_1_50820
    }
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_1.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1199165_1_50820
implementStatisticsUpdateExecuteProgressComReqDto_1.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1199166_1_50820
implementStatisticsUpdateExecuteProgressComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1199167_1_50820
    }

    /*D3更新执行进度(公共)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getExecuteProgressValue(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getObjectId(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getUseTypeCode(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getThemeContentId(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_1 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_1)/*vcase invoke isSameApp*/;



      }
      }
//ModelCode: circulationEnd
        }

      }
else if((listOmsEvaluationObjectTargetCycle!= null&&  listOmsEvaluationObjectTargetCycle !=null && listOmsEvaluationObjectTargetCycle.size()==0)){
       //elseif(3-3-09-03查评价模板部门目标任务书根节点列表.被评对象目标周期列表数据集条数 等于 0)  50821

ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_2 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_2=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_2.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1199163_1_50822
implementStatisticsUpdateExecuteProgressComReqDto_2.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1199165_1_50822
implementStatisticsUpdateExecuteProgressComReqDto_2.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1199166_1_50822
implementStatisticsUpdateExecuteProgressComReqDto_2.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1199167_1_50822
    }

    /*D3更新执行进度(公共)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getExecuteProgressValue(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getObjectId(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getUseTypeCode(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getThemeContentId(),"D3执行自定动计算部门任务书树平均权重(公共)-D3更新执行进度(公共)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_2 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_2)/*vcase invoke isSameApp*/;



      }
ImplementAutoCountDeptTaskAverageWeightComRespDto retData = new ImplementAutoCountDeptTaskAverageWeightComRespDto();





return retData;
  }
/**
   * D3执行批次发布自动计算平均权重(公共)[7587]
   * gen by moon at 10/21/2023, 10:46:41 PM
   */
  @Trace(operationName = "D3执行批次发布自动计算平均权重(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementBatchPublishAutoCountAverageWeightComRespDto implementBatchPublishAutoCountAverageWeightCom(ImplementBatchPublishAutoCountAverageWeightComReqDto reqDto){


      //virtualUsage D2-3查模板周期设置答案  50717
      QuerySchemeClassMatchEvaTempAnswerDetailComRespDto querySchemeClassMatchEvaTempAnswerDetailComRespDto = null;
    QuerySchemeClassMatchEvaTempAnswerDetailComReqDto querySchemeClassMatchEvaTempAnswerDetailComReqDto=new QuerySchemeClassMatchEvaTempAnswerDetailComReqDto();
  querySchemeClassMatchEvaTempAnswerDetailComReqDto.setConfItemClassCode("CYCLE_SCHEME_CLASS");//CUSTOM_CONVENTION//sourceId:1196349_1_50717
querySchemeClassMatchEvaTempAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1196405_1_50717
if(reqDto!=null){
      querySchemeClassMatchEvaTempAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1196351_1_50717
    }

    /*D2-3查模板周期设置答案[3069]   */
    Assert.isNull(querySchemeClassMatchEvaTempAnswerDetailComReqDto.getResultAspObjId(),"D3执行批次发布自动计算平均权重(公共)-D2-3查模板周期设置答案-评价模板ID不能为空",false);
Assert.isNull(querySchemeClassMatchEvaTempAnswerDetailComReqDto.getConfItemClassCode(),"D3执行批次发布自动计算平均权重(公共)-D2-3查模板周期设置答案-分组标识不能为空",false);
Assert.isNull(querySchemeClassMatchEvaTempAnswerDetailComReqDto.getIsPlatData(),"D3执行批次发布自动计算平均权重(公共)-D2-3查模板周期设置答案-是否标准答案不能为空",false);
      querySchemeClassMatchEvaTempAnswerDetailComRespDto = fwCompConfSchemeClient.querySchemeClassMatchEvaTempAnswerDetailCom(querySchemeClassMatchEvaTempAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D2-3查模板小数点规则配置答案  50718
      QuerySchemeClassMatchEvaTempAnswerDetailComRespDto querySchemeClassMatchEvaTempAnswerDetailComRespDto_2 = null;
    QuerySchemeClassMatchEvaTempAnswerDetailComReqDto querySchemeClassMatchEvaTempAnswerDetailComReqDto_1=new QuerySchemeClassMatchEvaTempAnswerDetailComReqDto();
  querySchemeClassMatchEvaTempAnswerDetailComReqDto_1.setConfItemClassCode("DECIMAL_POINT_RULES_SET_CLASS");//CUSTOM_CONVENTION//sourceId:1196412_1_50718
querySchemeClassMatchEvaTempAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1196468_1_50718
if(reqDto!=null){
      querySchemeClassMatchEvaTempAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1196414_1_50718
    }

    /*D2-3查模板小数点规则配置答案[3069]   */
    Assert.isNull(querySchemeClassMatchEvaTempAnswerDetailComReqDto_1.getResultAspObjId(),"D3执行批次发布自动计算平均权重(公共)-D2-3查模板小数点规则配置答案-评价模板ID不能为空",false);
Assert.isNull(querySchemeClassMatchEvaTempAnswerDetailComReqDto_1.getConfItemClassCode(),"D3执行批次发布自动计算平均权重(公共)-D2-3查模板小数点规则配置答案-分组标识不能为空",false);
Assert.isNull(querySchemeClassMatchEvaTempAnswerDetailComReqDto_1.getIsPlatData(),"D3执行批次发布自动计算平均权重(公共)-D2-3查模板小数点规则配置答案-是否标准答案不能为空",false);
      querySchemeClassMatchEvaTempAnswerDetailComRespDto_2 = fwCompConfSchemeClient.querySchemeClassMatchEvaTempAnswerDetailCom(querySchemeClassMatchEvaTempAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D3执行自动计算评价对象树平均权重(15%)  50719
      ImplementAutoCountEvaObjectAverageWeightComRespDto implementAutoCountEvaObjectAverageWeightComRespDto = null;
    if(querySchemeClassMatchEvaTempAnswerDetailComRespDto !=null&&querySchemeClassMatchEvaTempAnswerDetailComRespDto_2 !=null){
          ImplementAutoCountEvaObjectAverageWeightComReqDto implementAutoCountEvaObjectAverageWeightComReqDto=new ImplementAutoCountEvaObjectAverageWeightComReqDto();
  implementAutoCountEvaObjectAverageWeightComReqDto.setExecuteProgressValue(Double.valueOf("15"));//CUSTOM_CONVENTION//sourceId:1199157_1_50719
  if(reqDto!=null){
      implementAutoCountEvaObjectAverageWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1196344_1_50719
implementAutoCountEvaObjectAverageWeightComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1199158_1_50719
implementAutoCountEvaObjectAverageWeightComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1199159_1_50719
    }
if(querySchemeClassMatchEvaTempAnswerDetailComRespDto!=null){
      implementAutoCountEvaObjectAverageWeightComReqDto.setPeriodicModeTypeCode(querySchemeClassMatchEvaTempAnswerDetailComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1196345_1_50719
implementAutoCountEvaObjectAverageWeightComReqDto.setOpenMidCycle(querySchemeClassMatchEvaTempAnswerDetailComRespDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1196346_1_50719
    }
if(querySchemeClassMatchEvaTempAnswerDetailComRespDto_2!=null){
      implementAutoCountEvaObjectAverageWeightComReqDto.setWeightPoint(querySchemeClassMatchEvaTempAnswerDetailComRespDto_2.getWeightPoint());//SimpleFieldAssign//sourceId:1199122_1_50719
implementAutoCountEvaObjectAverageWeightComReqDto.setWeightDecimalPoint(querySchemeClassMatchEvaTempAnswerDetailComRespDto_2.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1199123_1_50719
implementAutoCountEvaObjectAverageWeightComReqDto.setDecimalDigitsLastRules(querySchemeClassMatchEvaTempAnswerDetailComRespDto_2.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1196348_1_50719
    }

    /*D3执行自动计算评价对象树平均权重(15%)[7582]   */
    Assert.isNull(implementAutoCountEvaObjectAverageWeightComReqDto.getEvaluationTemplateId(),"D3执行批次发布自动计算平均权重(公共)-D3执行自动计算评价对象树平均权重(15%)-冗余评价模板ID不能为空",false);
Assert.isNull(implementAutoCountEvaObjectAverageWeightComReqDto.getPeriodicModeTypeCode(),"D3执行批次发布自动计算平均权重(公共)-D3执行自动计算评价对象树平均权重(15%)-周期模式类型编码不能为空",false);
Assert.isNull(implementAutoCountEvaObjectAverageWeightComReqDto.getOpenMidCycle(),"D3执行批次发布自动计算平均权重(公共)-D3执行自动计算评价对象树平均权重(15%)-是否开启中期不能为空",false);
Assert.isNull(implementAutoCountEvaObjectAverageWeightComReqDto.getWeightPoint(),"D3执行批次发布自动计算平均权重(公共)-D3执行自动计算评价对象树平均权重(15%)-权重小数点规则不能为空",false);
Assert.isNull(implementAutoCountEvaObjectAverageWeightComReqDto.getWeightDecimalPoint(),"D3执行批次发布自动计算平均权重(公共)-D3执行自动计算评价对象树平均权重(15%)-权重分小数点规则   不能为空",false);
Assert.isNull(implementAutoCountEvaObjectAverageWeightComReqDto.getDecimalDigitsLastRules(),"D3执行批次发布自动计算平均权重(公共)-D3执行自动计算评价对象树平均权重(15%)-小数最后一位规则不能为空",false);
Assert.isNull(implementAutoCountEvaObjectAverageWeightComReqDto.getExecuteProgressValue(),"D3执行批次发布自动计算平均权重(公共)-D3执行自动计算评价对象树平均权重(15%)-执行进度值不能为空",false);
Assert.isNull(implementAutoCountEvaObjectAverageWeightComReqDto.getUseTypeCode(),"D3执行批次发布自动计算平均权重(公共)-D3执行自动计算评价对象树平均权重(15%)-用途类型编码不能为空",false);
Assert.isNull(implementAutoCountEvaObjectAverageWeightComReqDto.getObjectId(),"D3执行批次发布自动计算平均权重(公共)-D3执行自动计算评价对象树平均权重(15%)-归属对象内容ID不能为空",false);
      implementAutoCountEvaObjectAverageWeightComRespDto = implementAutoCountEvaObjectAverageWeightCom(implementAutoCountEvaObjectAverageWeightComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//virtualUsage D3执行自定动计算部门任务书树平均权重(20%)  50720
      ImplementAutoCountDeptTaskAverageWeightComRespDto implementAutoCountDeptTaskAverageWeightComRespDto = null;
    if(querySchemeClassMatchEvaTempAnswerDetailComRespDto !=null&&querySchemeClassMatchEvaTempAnswerDetailComRespDto_2 !=null){
          ImplementAutoCountDeptTaskAverageWeightComReqDto implementAutoCountDeptTaskAverageWeightComReqDto=new ImplementAutoCountDeptTaskAverageWeightComReqDto();
  implementAutoCountDeptTaskAverageWeightComReqDto.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1199219_1_50720
  if(reqDto!=null){
      implementAutoCountDeptTaskAverageWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1196339_1_50720
implementAutoCountDeptTaskAverageWeightComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1199220_1_50720
implementAutoCountDeptTaskAverageWeightComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1199221_1_50720
    }
if(querySchemeClassMatchEvaTempAnswerDetailComRespDto!=null){
      implementAutoCountDeptTaskAverageWeightComReqDto.setPeriodicModeTypeCode(querySchemeClassMatchEvaTempAnswerDetailComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1196340_1_50720
implementAutoCountDeptTaskAverageWeightComReqDto.setOpenMidCycle(querySchemeClassMatchEvaTempAnswerDetailComRespDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1196341_1_50720
    }
if(querySchemeClassMatchEvaTempAnswerDetailComRespDto_2!=null){
      implementAutoCountDeptTaskAverageWeightComReqDto.setWeightPoint(querySchemeClassMatchEvaTempAnswerDetailComRespDto_2.getWeightPoint());//SimpleFieldAssign//sourceId:1199124_1_50720
implementAutoCountDeptTaskAverageWeightComReqDto.setWeightDecimalPoint(querySchemeClassMatchEvaTempAnswerDetailComRespDto_2.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1199125_1_50720
implementAutoCountDeptTaskAverageWeightComReqDto.setDecimalDigitsLastRules(querySchemeClassMatchEvaTempAnswerDetailComRespDto_2.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1196343_1_50720
    }

    /*D3执行自定动计算部门任务书树平均权重(20%)[7583]   */
    Assert.isNull(implementAutoCountDeptTaskAverageWeightComReqDto.getEvaluationTemplateId(),"D3执行批次发布自动计算平均权重(公共)-D3执行自定动计算部门任务书树平均权重(20%)-冗余评价模板ID不能为空",false);
Assert.isNull(implementAutoCountDeptTaskAverageWeightComReqDto.getPeriodicModeTypeCode(),"D3执行批次发布自动计算平均权重(公共)-D3执行自定动计算部门任务书树平均权重(20%)-周期模式类型编码不能为空",false);
Assert.isNull(implementAutoCountDeptTaskAverageWeightComReqDto.getOpenMidCycle(),"D3执行批次发布自动计算平均权重(公共)-D3执行自定动计算部门任务书树平均权重(20%)-是否开启中期不能为空",false);
Assert.isNull(implementAutoCountDeptTaskAverageWeightComReqDto.getWeightPoint(),"D3执行批次发布自动计算平均权重(公共)-D3执行自定动计算部门任务书树平均权重(20%)-权重小数点规则不能为空",false);
Assert.isNull(implementAutoCountDeptTaskAverageWeightComReqDto.getWeightDecimalPoint(),"D3执行批次发布自动计算平均权重(公共)-D3执行自定动计算部门任务书树平均权重(20%)-权重分小数点规则   不能为空",false);
Assert.isNull(implementAutoCountDeptTaskAverageWeightComReqDto.getDecimalDigitsLastRules(),"D3执行批次发布自动计算平均权重(公共)-D3执行自定动计算部门任务书树平均权重(20%)-小数最后一位规则不能为空",false);
Assert.isNull(implementAutoCountDeptTaskAverageWeightComReqDto.getExecuteProgressValue(),"D3执行批次发布自动计算平均权重(公共)-D3执行自定动计算部门任务书树平均权重(20%)-执行进度值不能为空",false);
Assert.isNull(implementAutoCountDeptTaskAverageWeightComReqDto.getUseTypeCode(),"D3执行批次发布自动计算平均权重(公共)-D3执行自定动计算部门任务书树平均权重(20%)-用途类型编码不能为空",false);
Assert.isNull(implementAutoCountDeptTaskAverageWeightComReqDto.getObjectId(),"D3执行批次发布自动计算平均权重(公共)-D3执行自定动计算部门任务书树平均权重(20%)-归属对象内容ID不能为空",false);
      implementAutoCountDeptTaskAverageWeightComRespDto = implementAutoCountDeptTaskAverageWeightCom(implementAutoCountDeptTaskAverageWeightComReqDto)/*vcase invoke 同服务,同domain*/;



           }
ImplementBatchPublishAutoCountAverageWeightComRespDto retData = new ImplementBatchPublishAutoCountAverageWeightComRespDto();





return retData;
  }
/**
   * D3执行分析下级权重(公共)[8521]
   * gen by moon at 2/22/2024, 9:06:30 PM
   */
  @Trace(operationName = "D3执行分析下级权重(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyseSubWeightComRespDto implementAnalyseSubWeightCom(ImplementAnalyseSubWeightComReqDto reqDto){


      ObtainReceiveOutFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M3约定权重为100  61626
      //ModelCode: receptionService
        ObtainReceiveOutFieldRespDto receptionServiceRes = null;
    ObtainReceiveOutFieldReqDto receptionServiceReq=new ObtainReceiveOutFieldReqDto();
  receptionServiceReq.setWeightValue(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:1558036_1_61626

    /*M3约定权重为100[4608]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getWeightValue(),"D3执行分析下级权重(公共)-M3约定权重为100-权重不能为空",false);
      receptionServiceRes = nbWeightTarget.obtainReceiveOutField(receptionServiceReq);



if((reqDto!= null&&  reqDto.getEvaObjTargetCycleWeightList() !=null && reqDto.getEvaObjTargetCycleWeightList().size()==1)) {
        //if(D3执行分析下级权重(公共).被评对象目标周期权重列表数据集条数 等于 1)  61617

//ModelCode: receptionService
        ObtainReceiveOutFieldRespDto receptionServiceRes_2 = null;
    ObtainReceiveOutFieldReqDto receptionServiceReq_1=new ObtainReceiveOutFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setComFloatField1(receptionServiceRes.getWeightValue());//SimpleFieldAssign//sourceId:1558064_1_61627
    }

    /*M3接收权重结果[4608]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getComFloatField1(),"D3执行分析下级权重(公共)-M3接收权重结果-通用数值字段1（小数型）不能为空",false);
      receptionServiceRes_2 = nbWeightTarget.obtainReceiveOutField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&&  reqDto.getEvaObjTargetCycleWeightList() !=null && reqDto.getEvaObjTargetCycleWeightList().size()>1)){
       //elseif(D3执行分析下级权重(公共).被评对象目标周期权重列表数据集条数 大于 1)  61618

ImplementCountNumberDataSetsComRespDto implementCountNumberDataSetsComRespDto = null;
    ImplementCountNumberDataSetsComReqDto implementCountNumberDataSetsComReqDto=new ImplementCountNumberDataSetsComReqDto();
  if(reqDto!= null&&  reqDto.getEvaObjTargetCycleWeightList() !=null&& !CollectionUtil.isEmpty(reqDto.getEvaObjTargetCycleWeightList())){
      implementCountNumberDataSetsComReqDto.setCountNumberDataSetsList(//objList-to-objLists
        reqDto.getEvaObjTargetCycleWeightList().stream().map(item -> {
            com.wicket.okrcomponent.integration.dto.CountNumberDataSetsDto elm = new com.wicket.okrcomponent.integration.dto.CountNumberDataSetsDto();
      if(item!=null){
      elm.setCommPrimaryKey(item.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:305064_2_61621
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1557371_1_61621
    }

    /*D2-执行统计数据集条数服务(公共)[5166]   */

      implementCountNumberDataSetsComRespDto = fwCompInterfaceModeClient.implementCountNumberDataSetsCom(implementCountNumberDataSetsComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



CalculateCalcServiceCollectionComRespDto calculateCalcServiceCollectionComRespDto = null;
    if(implementCountNumberDataSetsComRespDto !=null){
          CalculateCalcServiceCollectionComReqDto calculateCalcServiceCollectionComReqDto=new CalculateCalcServiceCollectionComReqDto();
  calculateCalcServiceCollectionComReqDto.setCalcFormula("DIVISION_OF_TWO_NUM");//sourceId:1558020_1_61625
if(receptionServiceRes!=null){
      calculateCalcServiceCollectionComReqDto.setCalcPara1(receptionServiceRes.getWeightValue());//SimpleFieldAssign//sourceId:1558022_1_61625
    }
if(implementCountNumberDataSetsComRespDto!=null){
      calculateCalcServiceCollectionComReqDto.setCalcPara2(implementCountNumberDataSetsComRespDto.getOutputNum()!=null?Double.valueOf(implementCountNumberDataSetsComRespDto.getOutputNum()):null);//SimpleFieldAssign//sourceId:1558023_1_61625
    }
if(reqDto!=null){
      calculateCalcServiceCollectionComReqDto.setDecimalPointRules(reqDto.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1558026_1_61625
calculateCalcServiceCollectionComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1558027_1_61625
    }

    /*D4-计算服务集合（两数相除)[5091]   */
    Assert.isNull(calculateCalcServiceCollectionComReqDto.getCalcFormula(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相除)-通用计算公式不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getCalcPara1(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相除)-计算入参1不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getCalcPara2(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相除)-计算入参2不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getDecimalPointRules(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相除)-小数点规则不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getDecimalDigitsLastRules(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相除)-小数最后一位规则不能为空",false);
      calculateCalcServiceCollectionComRespDto = fwCalcCalculationRulesClient.calculateCalcServiceCollectionCom(calculateCalcServiceCollectionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CalculateDataBigMiniRecordComRespDto calculateDataBigMiniRecordComRespDto = null;
    CalculateDataBigMiniRecordComReqDto calculateDataBigMiniRecordComReqDto=new CalculateDataBigMiniRecordComReqDto();
  calculateDataBigMiniRecordComReqDto.setCalcMaxAndMin("MAX");//sourceId:1557691_1_61622
if(reqDto!= null&&  reqDto.getEvaObjTargetCycleWeightList() !=null&& !CollectionUtil.isEmpty(reqDto.getEvaObjTargetCycleWeightList())){
      calculateDataBigMiniRecordComReqDto.setDataBigMiniRecordList(//objList-to-objLists
        reqDto.getEvaObjTargetCycleWeightList().stream().map(item -> {
      DataBigMiniRecordDto elm = new DataBigMiniRecordDto();
      if(item!=null){
      elm.setContentID(item.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:305162_2_61622
elm.setOutputNum(item.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:305163_2_61622
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1557690_1_61622
    }

    /*D2计算数据集最大小值记录(公共)[5162]   */
    Assert.isNull(calculateDataBigMiniRecordComReqDto.getCalcMaxAndMin(),"D3执行分析下级权重(公共)-D2计算数据集最大小值记录(公共)-求最大最小值不能为空",false);
      calculateDataBigMiniRecordComRespDto = fwCompInterfaceModeClient.calculateDataBigMiniRecordCom(calculateDataBigMiniRecordComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



ObtainDataFilterSpecRecByComRespDto obtainDataFilterSpecRecByComRespDto = null;
    if(calculateDataBigMiniRecordComRespDto !=null){
          ObtainDataFilterSpecRecByComReqDto obtainDataFilterSpecRecByComReqDto=new ObtainDataFilterSpecRecByComReqDto();
  if(reqDto!= null&&  reqDto.getEvaObjTargetCycleWeightList() !=null&& !CollectionUtil.isEmpty(reqDto.getEvaObjTargetCycleWeightList())){
      obtainDataFilterSpecRecByComReqDto.setDataFilterSpecRecByList(reqDto.getEvaObjTargetCycleWeightList().stream().map(item->{
          DataFilterSpecRecByDto elm = new DataFilterSpecRecByDto();
          elm.setComTxtField(item.getObjTargetCycleWeightSetId());
          return elm;
      }).collect(Collectors.toList()));/*list-to-strings*///sourceId:1558015_1_61623
    }
if(calculateDataBigMiniRecordComRespDto!=null){
      obtainDataFilterSpecRecByComReqDto.setComTxtField(calculateDataBigMiniRecordComRespDto.getContentID());//SimpleFieldAssign//sourceId:1558014_1_61623
    }

    /*D2执行数据集减一条排序最大的记录(下级对象B)[7387]   */
    Assert.isNull(obtainDataFilterSpecRecByComReqDto.getComTxtField(),"D3执行分析下级权重(公共)-D2执行数据集减一条排序最大的记录(下级对象B)-通用文本字段不能为空",false);
      obtainDataFilterSpecRecByComRespDto = fwCompInterfaceModeClient.obtainDataFilterSpecRecByCom(obtainDataFilterSpecRecByComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ImplementCountNumberDataSetsComRespDto implementCountNumberDataSetsComRespDto_2 = null;
    if(obtainDataFilterSpecRecByComRespDto !=null){
          ImplementCountNumberDataSetsComReqDto implementCountNumberDataSetsComReqDto_1=new ImplementCountNumberDataSetsComReqDto();
  if(obtainDataFilterSpecRecByComRespDto!=null){
      //simpleList-to-objLists
    for (DataFilterSpecRecByDto item : obtainDataFilterSpecRecByComRespDto.getDataFilterSpecRecByList()) {
        com.wicket.okrcomponent.integration.dto.CountNumberDataSetsDto oneItem = new com.wicket.okrcomponent.integration.dto.CountNumberDataSetsDto();
                if(obtainDataFilterSpecRecByComRespDto!=null){
      oneItem.setCommPrimaryKey(item.getComTxtField());//SimpleFieldAssign//sourceId:305064_2_61624
    }

                implementCountNumberDataSetsComReqDto_1.getCountNumberDataSetsList().add(oneItem);
            }//sourceId:1557371_1_61624
    }

    /*D2-执行统计数据集条数服务(公共)[5166]   */

      implementCountNumberDataSetsComRespDto_2 = fwCompInterfaceModeClient.implementCountNumberDataSetsCom(implementCountNumberDataSetsComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CalculateCalcServiceCollectionComRespDto calculateCalcServiceCollectionComRespDto_2 = null;
    if(implementCountNumberDataSetsComRespDto_2 !=null&&calculateCalcServiceCollectionComRespDto !=null){
          CalculateCalcServiceCollectionComReqDto calculateCalcServiceCollectionComReqDto_1=new CalculateCalcServiceCollectionComReqDto();
  calculateCalcServiceCollectionComReqDto_1.setCalcFormula("MULTI_OF_TWO_NUM");//sourceId:1558040_1_61628
if(implementCountNumberDataSetsComRespDto_2!=null){
      calculateCalcServiceCollectionComReqDto_1.setCalcPara1(implementCountNumberDataSetsComRespDto_2.getOutputNum()!=null?Double.valueOf(implementCountNumberDataSetsComRespDto_2.getOutputNum()):null);//SimpleFieldAssign//sourceId:1558042_1_61628
    }
if(calculateCalcServiceCollectionComRespDto!=null){
      calculateCalcServiceCollectionComReqDto_1.setCalcPara2(calculateCalcServiceCollectionComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1558043_1_61628
    }
if(reqDto!=null){
      calculateCalcServiceCollectionComReqDto_1.setDecimalPointRules(reqDto.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1558046_1_61628
calculateCalcServiceCollectionComReqDto_1.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1558047_1_61628
    }

    /*D4-计算服务集合（两数相乘)[5091]   */
    Assert.isNull(calculateCalcServiceCollectionComReqDto_1.getCalcFormula(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相乘)-通用计算公式不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto_1.getCalcPara1(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相乘)-计算入参1不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto_1.getCalcPara2(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相乘)-计算入参2不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto_1.getDecimalPointRules(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相乘)-小数点规则不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto_1.getDecimalDigitsLastRules(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相乘)-小数最后一位规则不能为空",false);
      calculateCalcServiceCollectionComRespDto_2 = fwCalcCalculationRulesClient.calculateCalcServiceCollectionCom(calculateCalcServiceCollectionComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CalculateCalcServiceCollectionComRespDto calculateCalcServiceCollectionComRespDto_4 = null;
    if(calculateCalcServiceCollectionComRespDto_2 !=null){
          CalculateCalcServiceCollectionComReqDto calculateCalcServiceCollectionComReqDto_2=new CalculateCalcServiceCollectionComReqDto();
  calculateCalcServiceCollectionComReqDto_2.setCalcFormula("SUBTRACTION_OF_TWO_NUM");//sourceId:1558050_1_61630
if(receptionServiceRes!=null){
      calculateCalcServiceCollectionComReqDto_2.setCalcPara1(receptionServiceRes.getWeightValue());//SimpleFieldAssign//sourceId:1558052_1_61630
    }
if(calculateCalcServiceCollectionComRespDto_2!=null){
      calculateCalcServiceCollectionComReqDto_2.setCalcPara2(calculateCalcServiceCollectionComRespDto_2.getCalcResult());//SimpleFieldAssign//sourceId:1558053_1_61630
    }

    /*D4-计算服务集合（两数相减)[5091]   */
    Assert.isNull(calculateCalcServiceCollectionComReqDto_2.getCalcFormula(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相减)-通用计算公式不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto_2.getCalcPara1(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相减)-计算入参1不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto_2.getCalcPara2(),"D3执行分析下级权重(公共)-D4-计算服务集合（两数相减)-计算入参2不能为空",false);
      calculateCalcServiceCollectionComRespDto_4 = fwCalcCalculationRulesClient.calculateCalcServiceCollectionCom(calculateCalcServiceCollectionComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        ObtainReceiveOutFieldRespDto receptionServiceRes_4 = null;
    if(calculateCalcServiceCollectionComRespDto !=null&&calculateDataBigMiniRecordComRespDto !=null&&calculateCalcServiceCollectionComRespDto_4 !=null){
          ObtainReceiveOutFieldReqDto receptionServiceReq_2=new ObtainReceiveOutFieldReqDto();
  if(calculateCalcServiceCollectionComRespDto!=null){
      receptionServiceReq_2.setComFloatField1(calculateCalcServiceCollectionComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1558064_1_61631
    }
if(calculateDataBigMiniRecordComRespDto!=null){
      receptionServiceReq_2.setObjTargetCycleWeightSetId(calculateDataBigMiniRecordComRespDto.getContentID());//SimpleFieldAssign//sourceId:1558070_1_61631
    }
if(calculateCalcServiceCollectionComRespDto_4!=null){
      receptionServiceReq_2.setComFloatField2(calculateCalcServiceCollectionComRespDto_4.getCalcResult());//SimpleFieldAssign//sourceId:1558065_1_61631
    }

    /*M3接收权重结果[4608]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getComFloatField1(),"D3执行分析下级权重(公共)-M3接收权重结果-通用数值字段1（小数型）不能为空",false);
      receptionServiceRes_4 = nbWeightTarget.obtainReceiveOutField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
           }
    }
ImplementAnalyseSubWeightComRespDto retData = new ImplementAnalyseSubWeightComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setWeightValue(receptionServiceRes_3.getComFloatField1());//SimpleFieldAssign//sourceId:1558072_1
retData.setObjTargetCycleWeightSetId(receptionServiceRes_3.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:1558073_1
retData.setMaxWeightValue(receptionServiceRes_3.getComFloatField2());//SimpleFieldAssign//sourceId:1558074_1
    }




return retData;
  }
/**
   * D3执行自动计算下级权重分(公共)[8522]
   * gen by moon at 2/22/2024, 9:06:43 PM
   */
  @Trace(operationName = "D3执行自动计算下级权重分(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAutoCountSubWeightScoreComRespDto implementAutoCountSubWeightScoreCom(ImplementAutoCountSubWeightScoreComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getEvaObjTargetCycleWeightList() !=null && reqDto.getEvaObjTargetCycleWeightList().size()>0)) {
        //if(D3执行自动计算下级权重分(公共).被评对象目标周期权重列表数据集条数 大于 0)  61635

//ModelCode: circulationCollections
        for (EvaObjTargetCycleWeightDto circulationCollectionsRes: reqDto.getEvaObjTargetCycleWeightList()){

CalculateCalcServiceCollectionComRespDto calculateCalcServiceCollectionComRespDto = null;
    CalculateCalcServiceCollectionComReqDto calculateCalcServiceCollectionComReqDto=new CalculateCalcServiceCollectionComReqDto();
  calculateCalcServiceCollectionComReqDto.setCalcFormula("MULTI_OF_TWO_NUM");//sourceId:1558460_1_61638
calculateCalcServiceCollectionComReqDto.setCalcPara2(Double.valueOf("0.01"));//CUSTOM_CONVENTION//sourceId:1558463_1_61638
calculateCalcServiceCollectionComReqDto.setDecimalPointRules(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1558466_1_61638
calculateCalcServiceCollectionComReqDto.setDecimalDigitsLastRules("MALING");//sourceId:1558467_1_61638
if(circulationCollectionsRes!=null){
      calculateCalcServiceCollectionComReqDto.setCalcPara1(circulationCollectionsRes.getWeightValue());//SimpleFieldAssign//sourceId:1558462_1_61638
    }

    /*D4-当前发牌的权重乘以0.01（公共）[5091]   */
    Assert.isNull(calculateCalcServiceCollectionComReqDto.getCalcFormula(),"D3执行自动计算下级权重分(公共)-D4-当前发牌的权重乘以0.01（公共）-通用计算公式不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getCalcPara1(),"D3执行自动计算下级权重分(公共)-D4-当前发牌的权重乘以0.01（公共）-计算入参1不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getCalcPara2(),"D3执行自动计算下级权重分(公共)-D4-当前发牌的权重乘以0.01（公共）-计算入参2不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getDecimalPointRules(),"D3执行自动计算下级权重分(公共)-D4-当前发牌的权重乘以0.01（公共）-小数点规则不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getDecimalDigitsLastRules(),"D3执行自动计算下级权重分(公共)-D4-当前发牌的权重乘以0.01（公共）-小数最后一位规则不能为空",false);
      calculateCalcServiceCollectionComRespDto = fwCalcCalculationRulesClient.calculateCalcServiceCollectionCom(calculateCalcServiceCollectionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



CalculateCalcServiceCollectionComRespDto calculateCalcServiceCollectionComRespDto_2 = null;
    if(calculateCalcServiceCollectionComRespDto !=null){
          CalculateCalcServiceCollectionComReqDto calculateCalcServiceCollectionComReqDto_1=new CalculateCalcServiceCollectionComReqDto();
  calculateCalcServiceCollectionComReqDto_1.setCalcFormula("MULTI_OF_TWO_NUM");//sourceId:1558470_1_61639
if(calculateCalcServiceCollectionComRespDto!=null){
      calculateCalcServiceCollectionComReqDto_1.setCalcPara1(calculateCalcServiceCollectionComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1558472_1_61639
    }
if(reqDto!=null){
      calculateCalcServiceCollectionComReqDto_1.setCalcPara2(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1558473_1_61639
calculateCalcServiceCollectionComReqDto_1.setDecimalPointRules(Long.valueOf(reqDto.getWeightDecimalPoint()));//SimpleFieldAssign//sourceId:1558476_1_61639
calculateCalcServiceCollectionComReqDto_1.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1558477_1_61639
    }

    /*D4-当前牌权重百分比值X上级权重分=计算当前牌权重分(公共)[5091]   */
    Assert.isNull(calculateCalcServiceCollectionComReqDto_1.getCalcFormula(),"D3执行自动计算下级权重分(公共)-D4-当前牌权重百分比值X上级权重分=计算当前牌权重分(公共)-通用计算公式不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto_1.getCalcPara1(),"D3执行自动计算下级权重分(公共)-D4-当前牌权重百分比值X上级权重分=计算当前牌权重分(公共)-计算入参1不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto_1.getCalcPara2(),"D3执行自动计算下级权重分(公共)-D4-当前牌权重百分比值X上级权重分=计算当前牌权重分(公共)-计算入参2不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto_1.getDecimalPointRules(),"D3执行自动计算下级权重分(公共)-D4-当前牌权重百分比值X上级权重分=计算当前牌权重分(公共)-小数点规则不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto_1.getDecimalDigitsLastRules(),"D3执行自动计算下级权重分(公共)-D4-当前牌权重百分比值X上级权重分=计算当前牌权重分(公共)-小数最后一位规则不能为空",false);
      calculateCalcServiceCollectionComRespDto_2 = fwCalcCalculationRulesClient.calculateCalcServiceCollectionCom(calculateCalcServiceCollectionComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
boolean bOOLEAN ;
    if(calculateCalcServiceCollectionComRespDto_2 !=null){
          OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet=new OmsEvaObjTargetCycleWeightSet();
  omsEvaObjTargetCycleWeightSet.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1558483_1_61640
omsEvaObjTargetCycleWeightSet.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1558484_1_61640
if(circulationCollectionsRes!=null){
      omsEvaObjTargetCycleWeightSet.setObjTargetCycleWeightSetId(circulationCollectionsRes.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:1558481_1_61640
    }
if(calculateCalcServiceCollectionComRespDto_2!=null){
      omsEvaObjTargetCycleWeightSet.setWeightScore(calculateCalcServiceCollectionComRespDto_2.getCalcResult());//SimpleFieldAssign//sourceId:1558482_1_61640
    }

    /*3-3-09-02更新权重分计算结果[5084]   */
    Assert.isNull(omsEvaObjTargetCycleWeightSet.getObjTargetCycleWeightSetId(),"D3执行自动计算下级权重分(公共)-3-3-09-02更新权重分计算结果-对象目标周期权重设置ID不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet.getWeightScore(),"D3执行自动计算下级权重分(公共)-3-3-09-02更新权重分计算结果-权重分值不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet.getOperationInductionId(),"D3执行自动计算下级权重分(公共)-3-3-09-02更新权重分计算结果-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaObjTargetCycleWeightSet.getOperateTime(),"D3执行自动计算下级权重分(公共)-3-3-09-02更新权重分计算结果-操作时间不能为空",false);
      bOOLEAN = mOmsEvaObjTargetCycleWeightSetService.updateEvaObjTargetCycleWeight(omsEvaObjTargetCycleWeightSet)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: circulationEnd
        }

      }
ImplementAutoCountSubWeightScoreComRespDto retData = new ImplementAutoCountSubWeightScoreComRespDto();





return retData;
  }
/**
   * D3查询上级目标全周期权重列表(公共)[9813]
   * gen by moon at 7/17/2024, 1:25:37 AM
   */
  @Trace(operationName = "D3查询上级目标全周期权重列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySuperiorTargetFullCycleListComRespDto querySuperiorTargetFullCycleListCom(QuerySuperiorTargetFullCycleListComReqDto reqDto){


      BatchQueryTargetCycleWeightComRespDto batchQueryTargetCycleWeightComRespDto_1 =null;
if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET")||reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_CATEGORY")||reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
        //if((D3查询上级目标周期权重列表(公共).冗余内容表类型编码 等于 目标表 or D3查询上级目标周期权重列表(公共).冗余内容表类型编码 等于 目标分类表 or D3查询上级目标周期权重列表(公共).冗余内容表类型编码 等于 指标表))  70024

QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto = null;
    QueryEvaTargetCycleListComReqDto queryEvaTargetCycleListComReqDto=new QueryEvaTargetCycleListComReqDto();
  queryEvaTargetCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1867914_1_70026
queryEvaTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1867922_1_70026
if(reqDto!=null){
      queryEvaTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1867916_1_70026
queryEvaTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1867921_1_70026
queryEvaTargetCycleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1867923_1_70026
    }

    /*D3查目标内容规划树目标周期列表(公共)[9416]   */
    Assert.isNull(queryEvaTargetCycleListComReqDto.getTargetCycleContentId(),"D3查询上级目标全周期权重列表(公共)-D3查目标内容规划树目标周期列表(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaluationTemplateId(),"D3查询上级目标全周期权重列表(公共)-D3查目标内容规划树目标周期列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjTypeCode(),"D3查询上级目标全周期权重列表(公共)-D3查目标内容规划树目标周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getIsArchive(),"D3查询上级目标全周期权重列表(公共)-D3查目标内容规划树目标周期列表(公共)-是否存档不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getSpaceId(),"D3查询上级目标全周期权重列表(公共)-D3查目标内容规划树目标周期列表(公共)-创建于空间ID不能为空",false);
      queryEvaTargetCycleListComRespDto = targetContComService.queryEvaTargetCycleListCom(queryEvaTargetCycleListComReqDto)/*vcase invoke isSameApp*/;



if((queryEvaTargetCycleListComRespDto!= null&&  queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null && queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3查目标内容规划树目标周期列表(公共).被评对象目标周期列表数据集条数 大于 0)  70027

BatchQueryTargetCycleWeightComRespDto batchQueryTargetCycleWeightComRespDto = null;
    if(queryEvaTargetCycleListComRespDto !=null){
          BatchQueryTargetCycleWeightComReqDto batchQueryTargetCycleWeightComReqDto=new BatchQueryTargetCycleWeightComReqDto();
  if(queryEvaTargetCycleListComRespDto!= null&&  queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList())){
      batchQueryTargetCycleWeightComReqDto.setEvaObjTargetCycleList(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1869034_1_70028
    }
if(reqDto!=null){
      batchQueryTargetCycleWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1869035_1_70028
    }

    /*D3批量查询目标周期权重(公共)[9814]   */
    Assert.isNull(batchQueryTargetCycleWeightComReqDto.getEvaluationTemplateId(),"D3查询上级目标全周期权重列表(公共)-D3批量查询目标周期权重(公共)-冗余评价模板ID不能为空",false);
      batchQueryTargetCycleWeightComRespDto = batchQueryTargetCycleWeightCom(batchQueryTargetCycleWeightComReqDto)/*vcase invoke 同服务,同domain*/;


      batchQueryTargetCycleWeightComRespDto_1 = batchQueryTargetCycleWeightComRespDto;
           }
      }
      }
else if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_EVALUATION_OBJECT_TARGET_CYCLE"))){
       //elseif(D3查询上级目标周期权重列表(公共).冗余内容表类型编码 等于 被评对象目标周期表)  70025

QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1867930_1_70029
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1867929_1_70029
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1867931_1_70029
queryEvaObjTargetCyclePlatformDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1867932_1_70029
    }

    /*D3查其他树目标周期详情(用于下文入参使用)[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(),"D3查询上级目标全周期权重列表(公共)-D3查其他树目标周期详情(用于下文入参使用)-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(),"D3查询上级目标全周期权重列表(公共)-D3查其他树目标周期详情(用于下文入参使用)-是否存档不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3查询上级目标全周期权重列表(公共)-D3查其他树目标周期详情(用于下文入参使用)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getSpaceId(),"D3查询上级目标全周期权重列表(公共)-D3查其他树目标周期详情(用于下文入参使用)-创建于空间ID不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;



QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto_2 = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          QueryEvaTargetCycleListComReqDto queryEvaTargetCycleListComReqDto_1=new QueryEvaTargetCycleListComReqDto();
  queryEvaTargetCycleListComReqDto_1.setIsArchive("FALSE");//sourceId:1867958_1_70031
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      queryEvaTargetCycleListComReqDto_1.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1867954_1_70031
queryEvaTargetCycleListComReqDto_1.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1867955_1_70031
queryEvaTargetCycleListComReqDto_1.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1867956_1_70031
    }
if(reqDto!=null){
      queryEvaTargetCycleListComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1867957_1_70031
queryEvaTargetCycleListComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1867959_1_70031
    }

    /*D3查其他树目标内容目标周期列表（用于批量查权重入参）[9416]   */
    Assert.isNull(queryEvaTargetCycleListComReqDto_1.getEvaObjEntityId(),"D3查询上级目标全周期权重列表(公共)-D3查其他树目标内容目标周期列表（用于批量查权重入参）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto_1.getEvaObjTypeCode(),"D3查询上级目标全周期权重列表(公共)-D3查其他树目标内容目标周期列表（用于批量查权重入参）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto_1.getTargetCycleContentId(),"D3查询上级目标全周期权重列表(公共)-D3查其他树目标内容目标周期列表（用于批量查权重入参）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto_1.getEvaluationTemplateId(),"D3查询上级目标全周期权重列表(公共)-D3查其他树目标内容目标周期列表（用于批量查权重入参）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto_1.getIsArchive(),"D3查询上级目标全周期权重列表(公共)-D3查其他树目标内容目标周期列表（用于批量查权重入参）-是否存档不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto_1.getSpaceId(),"D3查询上级目标全周期权重列表(公共)-D3查其他树目标内容目标周期列表（用于批量查权重入参）-创建于空间ID不能为空",false);
      queryEvaTargetCycleListComRespDto_2 = targetContComService.queryEvaTargetCycleListCom(queryEvaTargetCycleListComReqDto_1)/*vcase invoke isSameApp*/;



           }
if((queryEvaTargetCycleListComRespDto_2!= null&&  queryEvaTargetCycleListComRespDto_2.getEvaObjTargetCycleList() !=null && queryEvaTargetCycleListComRespDto_2.getEvaObjTargetCycleList().size()>0)) {
        //if(D3查其他树目标内容目标周期列表（用于批量查权重入参）.被评对象目标周期列表数据集条数 大于 0)  70032

BatchQueryTargetCycleWeightComRespDto batchQueryTargetCycleWeightComRespDto_2 = null;
    if(queryEvaTargetCycleListComRespDto_2 !=null){
          BatchQueryTargetCycleWeightComReqDto batchQueryTargetCycleWeightComReqDto_1=new BatchQueryTargetCycleWeightComReqDto();
  if(queryEvaTargetCycleListComRespDto_2!= null&&  queryEvaTargetCycleListComRespDto_2.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto_2.getEvaObjTargetCycleList())){
      batchQueryTargetCycleWeightComReqDto_1.setEvaObjTargetCycleList(queryEvaTargetCycleListComRespDto_2.getEvaObjTargetCycleList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1869034_1_70033
    }
if(reqDto!=null){
      batchQueryTargetCycleWeightComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1869035_1_70033
    }

    /*D3批量查询目标周期权重(公共)[9814]   */
    Assert.isNull(batchQueryTargetCycleWeightComReqDto_1.getEvaluationTemplateId(),"D3查询上级目标全周期权重列表(公共)-D3批量查询目标周期权重(公共)-冗余评价模板ID不能为空",false);
      batchQueryTargetCycleWeightComRespDto_2 = batchQueryTargetCycleWeightCom(batchQueryTargetCycleWeightComReqDto_1)/*vcase invoke 同服务,同domain*/;


      batchQueryTargetCycleWeightComRespDto_1 = batchQueryTargetCycleWeightComRespDto_2;
           }
      }
    }
QuerySuperiorTargetFullCycleListComRespDto retData = new QuerySuperiorTargetFullCycleListComRespDto();
  if(batchQueryTargetCycleWeightComRespDto_1!=null){
      retData.setEvaObjTargetCycleWeightList(batchQueryTargetCycleWeightComRespDto_1.getEvaObjTargetCycleWeightList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1867960_1
    }




return retData;
  }
/**
   * D3批量查询目标周期权重(公共)[9814]
   * gen by moon at 6/16/2024, 3:05:43 AM
   */
  @Trace(operationName = "D3批量查询目标周期权重(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchQueryTargetCycleWeightComRespDto batchQueryTargetCycleWeightCom(BatchQueryTargetCycleWeightComReqDto reqDto){


      List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet_1 =new ArrayList<>();
List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 =new ArrayList<>();
//步骤0: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
     //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleList(reqDto.getEvaObjTargetCycleList());//list-field-assign//sourceId:1867798_1
receptionServiceReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1869013_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1867799_1
    }

    /*M3接收入参字段[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3批量查询目标周期权重(公共)-M3接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbWeightTarget.implementFiveReceivingField(receptionServiceReq);




//步骤1: 3-3-09-02批量查询被评对象目标周期权重 - batchQueryEvaObjTargetCycleWeight
     List<OmsEvaObjTargetCycleWeightSet> listOmsEvaObjTargetCycleWeightSet =new ArrayList<>();
    BatchQueryEvaObjTargetCycleWeightReq batchQueryEvaObjTargetCycleWeightReq=new BatchQueryEvaObjTargetCycleWeightReq();
  batchQueryEvaObjTargetCycleWeightReq.setIsArchive("FALSE");//sourceId:1867804_1
if(reqDto!=null){
      batchQueryEvaObjTargetCycleWeightReq.setEvaObjTargetCycleWeightList(reqDto.getEvaObjTargetCycleList());//list-field-assign//sourceId:1867800_1
batchQueryEvaObjTargetCycleWeightReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1869012_1
batchQueryEvaObjTargetCycleWeightReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1867805_1
    }

    /*3-3-09-02批量查询被评对象目标周期权重[2745]   */
    Assert.isNull(batchQueryEvaObjTargetCycleWeightReq.getEvaluationTemplateId(),"D3批量查询目标周期权重(公共)-3-3-09-02批量查询被评对象目标周期权重-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleWeightReq.getIsArchive(),"D3批量查询目标周期权重(公共)-3-3-09-02批量查询被评对象目标周期权重-是否存档不能为空",false);
      listOmsEvaObjTargetCycleWeightSet = mOmsEvaObjTargetCycleWeightSetService.batchQueryEvaObjTargetCycleWeight(batchQueryEvaObjTargetCycleWeightReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaObjTargetCycleWeightSet_1 = listOmsEvaObjTargetCycleWeightSet;

//步骤2: 3-3-09批量查被评对象目标周期列表 - batchQueryEvaObjTargetCycle
     List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    if(listOmsEvaObjTargetCycleWeightSet !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)&& listOmsEvaObjTargetCycleWeightSet.size()>0 ){
          BatchQueryEvaObjTargetCycleReq batchQueryEvaObjTargetCycleReq=new BatchQueryEvaObjTargetCycleReq();
  batchQueryEvaObjTargetCycleReq.setIsArchive("FALSE");//sourceId:1867816_1
if(listOmsEvaObjTargetCycleWeightSet!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)&&  listOmsEvaObjTargetCycleWeightSet !=null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet)){
      batchQueryEvaObjTargetCycleReq.setEvaObjTargetCycleList(listOmsEvaObjTargetCycleWeightSet.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1867811_1
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1867815_1
    }

    /*3-3-09批量查被评对象目标周期列表[2335]   */
    Assert.isNull(batchQueryEvaObjTargetCycleReq.getEvaluationTemplateId(),"D3批量查询目标周期权重(公共)-3-3-09批量查被评对象目标周期列表-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleReq.getIsArchive(),"D3批量查询目标周期权重(公共)-3-3-09批量查被评对象目标周期列表-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.batchQueryEvaObjTargetCycle(batchQueryEvaObjTargetCycleReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;
           }

BatchQueryTargetCycleWeightComRespDto retData = new BatchQueryTargetCycleWeightComRespDto();
  //数据集融合  MoreListToOneSource
        if(listOmsEvaObjTargetCycleWeightSet_1!= null&& !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_1) && !CollectionUtil.isEmpty(listOmsEvaObjTargetCycleWeightSet_1) ){
          for (OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet : listOmsEvaObjTargetCycleWeightSet_1) {
              EvaObjTargetCycleWeightDto retElm = new EvaObjTargetCycleWeightDto();
             retElm.setObjTargetCycleWeightSetId(omsEvaObjTargetCycleWeightSet.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:373657_2
retElm.setEvaObjTargetCycleId(omsEvaObjTargetCycleWeightSet.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:373658_2
retElm.setParentSubMidCycleType(omsEvaObjTargetCycleWeightSet.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:373659_2
retElm.setWeightValue(omsEvaObjTargetCycleWeightSet.getWeightValue());//SimpleFieldAssign//sourceId:373660_2
retElm.setWeightScore(omsEvaObjTargetCycleWeightSet.getWeightScore());//SimpleFieldAssign//sourceId:373661_2
              retData.getEvaObjTargetCycleWeightList().add(retElm);
               if(listOmsEvaluationObjectTargetCycle_1!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_1)){
          for (OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle : listOmsEvaluationObjectTargetCycle_1) {
                if (omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId().equals(omsEvaObjTargetCycleWeightSet.getEvaObjTargetCycleId())) {
                 retElm.setCyclelAlias(omsEvaluationObjectTargetCycle.getCyclelAlias());//SimpleFieldAssign//sourceId:374319_2
retElm.setTargetCycleName(omsEvaluationObjectTargetCycle.getTargetCycleName());//SimpleFieldAssign//sourceId:374320_2
retElm.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:373662_2
retElm.setCycleStandardName(omsEvaluationObjectTargetCycle.getCycleStandardName());//SimpleFieldAssign//sourceId:373663_2
retElm.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:374342_2
                }
            }
          }

          }
        }//sourceId:1867828_1




return retData;
  }
/**
   * D3分析是否只查看目标父周期(公共)[9815]
   * gen by moon at 6/16/2024, 7:53:53 PM
   */
  @Trace(operationName = "D3分析是否只查看目标父周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisIsOnlyQueryTargetParentCycleComRespDto analysisIsOnlyQueryTargetParentCycleCom(AnalysisIsOnlyQueryTargetParentCycleComReqDto reqDto){


      QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto_1 =null;
      AnalysisHomozygousBetweenFatherAndSonComRespDto analysisHomozygousBetweenFatherAndSonComRespDto_1 =null;
ImplementSixReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage D2查评价模板周期模式配置参数（公共）  70059
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("CYCLE_MODE");//CUSTOM_CONVENTION//sourceId:1868407_1_70059
queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1868406_1_70059
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1868408_1_70059
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1868405_1_70059
    }

    /*D2查评价模板周期模式配置参数（公共）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3分析是否只查看目标父周期(公共)-D2查评价模板周期模式配置参数（公共）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3分析是否只查看目标父周期(公共)-D2查评价模板周期模式配置参数（公共）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D3分析是否只查看目标父周期(公共)-D2查评价模板周期模式配置参数（公共）-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3分析是否只查看目标父周期(公共)-D2查评价模板周期模式配置参数（公共）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage M3接收周期模式出参  70060
      //ModelCode: receptionService
        ImplementSixReceivingFieldRespDto receptionServiceRes = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null){
          ImplementSixReceivingFieldReqDto receptionServiceReq=new ImplementSixReceivingFieldReqDto();
  if(queryConfItemMatchAnswerDetailComRespDto!=null){
      receptionServiceReq.setPeriodicModeTypeCode(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1871242_1_70060
    }

    /*M3接收周期模式出参[8635]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getPeriodicModeTypeCode(),"D3分析是否只查看目标父周期(公共)-M3接收周期模式出参-周期模式类型编码不能为空",false);
      receptionServiceRes = nbWeightTarget.implementSixReceivingField(receptionServiceReq);



           }
//virtualUsage D3分析被评对象内容表主键ID(公共)  70061
      AnalysisEvaObjEntityIdComRespDto analysisEvaObjEntityIdComRespDto = null;
    AnalysisEvaObjEntityIdComReqDto analysisEvaObjEntityIdComReqDto=new AnalysisEvaObjEntityIdComReqDto();
  if(reqDto!=null){
      analysisEvaObjEntityIdComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1871353_1_70061
analysisEvaObjEntityIdComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1871354_1_70061
analysisEvaObjEntityIdComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1871355_1_70061
analysisEvaObjEntityIdComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1871356_1_70061
    }

    /*D3分析被评对象内容表主键ID(公共)[9818]   */
    Assert.isNull(analysisEvaObjEntityIdComReqDto.getTableTypeCode(),"D3分析是否只查看目标父周期(公共)-D3分析被评对象内容表主键ID(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(analysisEvaObjEntityIdComReqDto.getEntityId(),"D3分析是否只查看目标父周期(公共)-D3分析被评对象内容表主键ID(公共)-冗余内容表主键ID不能为空",false);
Assert.isNull(analysisEvaObjEntityIdComReqDto.getEvaluationTemplateId(),"D3分析是否只查看目标父周期(公共)-D3分析被评对象内容表主键ID(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(analysisEvaObjEntityIdComReqDto.getSpaceId(),"D3分析是否只查看目标父周期(公共)-D3分析被评对象内容表主键ID(公共)-创建于空间ID不能为空",false);
      analysisEvaObjEntityIdComRespDto = analysisEvaObjEntityIdCom(analysisEvaObjEntityIdComReqDto)/*vcase invoke 同服务,同domain*/;



//virtualUsage D3查询目标内容父周期ID  70062
      QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    if(analysisEvaObjEntityIdComRespDto !=null){
          QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto.setIsParentCycle("TRUE");//sourceId:1868481_1_70062
queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1868482_1_70062
if(analysisEvaObjEntityIdComRespDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjEntityId(analysisEvaObjEntityIdComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1868479_1_70062
queryEvaObjTargetCyclePlatformDetailComReqDto.setTargetCycleContentId(analysisEvaObjEntityIdComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1868480_1_70062
    }
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1868483_1_70062
queryEvaObjTargetCyclePlatformDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1868484_1_70062
    }

    /*D3查询目标内容父周期ID[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjEntityId(),"D3分析是否只查看目标父周期(公共)-D3查询目标内容父周期ID-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getTargetCycleContentId(),"D3分析是否只查看目标父周期(公共)-D3查询目标内容父周期ID-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsParentCycle(),"D3分析是否只查看目标父周期(公共)-D3查询目标内容父周期ID-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3分析是否只查看目标父周期(公共)-D3查询目标内容父周期ID-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(),"D3分析是否只查看目标父周期(公共)-D3查询目标内容父周期ID-是否存档不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getSpaceId(),"D3分析是否只查看目标父周期(公共)-D3查询目标内容父周期ID-创建于空间ID不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;


      queryEvaObjTargetCyclePlatformDetailComRespDto_1 = queryEvaObjTargetCyclePlatformDetailComRespDto;
           }
//virtualUsage D3分析父子中同体(公共)  70063
      AnalysisHomozygousBetweenFatherAndSonComRespDto analysisHomozygousBetweenFatherAndSonComRespDto = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null&&queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          AnalysisHomozygousBetweenFatherAndSonComReqDto analysisHomozygousBetweenFatherAndSonComReqDto=new AnalysisHomozygousBetweenFatherAndSonComReqDto();
  if(queryConfItemMatchAnswerDetailComRespDto!=null){
      analysisHomozygousBetweenFatherAndSonComReqDto.setPeriodicModeTypeCode(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1868375_1_70063
    }
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      analysisHomozygousBetweenFatherAndSonComReqDto.setEvaObjTargetCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1868370_1_70063
    }
if(reqDto!=null){
      analysisHomozygousBetweenFatherAndSonComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1868372_1_70063
    }

    /*D3分析父子中同体(公共)[8573]   */
    Assert.isNull(analysisHomozygousBetweenFatherAndSonComReqDto.getPeriodicModeTypeCode(),"D3分析是否只查看目标父周期(公共)-D3分析父子中同体(公共)-周期模式类型编码不能为空",false);
Assert.isNull(analysisHomozygousBetweenFatherAndSonComReqDto.getEvaObjTargetCycleId(),"D3分析是否只查看目标父周期(公共)-D3分析父子中同体(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(analysisHomozygousBetweenFatherAndSonComReqDto.getEvaluationTemplateId(),"D3分析是否只查看目标父周期(公共)-D3分析父子中同体(公共)-冗余评价模板ID不能为空",false);
      analysisHomozygousBetweenFatherAndSonComRespDto = targetCalcService.analysisHomozygousBetweenFatherAndSonCom(analysisHomozygousBetweenFatherAndSonComReqDto)/*vcase invoke isSameApp*/;


      analysisHomozygousBetweenFatherAndSonComRespDto_1 = analysisHomozygousBetweenFatherAndSonComRespDto;
           }
//virtualUsage D3分析是否克隆子或中期权重(公共)  70092
      AnalysisIsCloneSubOrMidWeightComRespDto analysisIsCloneSubOrMidWeightComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null&&analysisHomozygousBetweenFatherAndSonComRespDto !=null){
          AnalysisIsCloneSubOrMidWeightComReqDto analysisIsCloneSubOrMidWeightComReqDto=new AnalysisIsCloneSubOrMidWeightComReqDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      analysisIsCloneSubOrMidWeightComReqDto.setEvaObjTargetCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1872957_1_70092
    }
if(reqDto!=null){
      analysisIsCloneSubOrMidWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1872958_1_70092
    }
if(analysisHomozygousBetweenFatherAndSonComRespDto!=null){
      analysisIsCloneSubOrMidWeightComReqDto.setFatherMidSubCycleDataModel(analysisHomozygousBetweenFatherAndSonComRespDto.getFatherMidSubCycleDataModel());//SimpleFieldAssign//sourceId:1872959_1_70092
    }

    /*D3分析是否克隆子或中期权重(公共)[9822]   */
    Assert.isNull(analysisIsCloneSubOrMidWeightComReqDto.getEvaObjTargetCycleId(),"D3分析是否只查看目标父周期(公共)-D3分析是否克隆子或中期权重(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(analysisIsCloneSubOrMidWeightComReqDto.getEvaluationTemplateId(),"D3分析是否只查看目标父周期(公共)-D3分析是否克隆子或中期权重(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(analysisIsCloneSubOrMidWeightComReqDto.getFatherMidSubCycleDataModel(),"D3分析是否只查看目标父周期(公共)-D3分析是否克隆子或中期权重(公共)-父子中周期数据同体模型不能为空",false);
      analysisIsCloneSubOrMidWeightComRespDto = analysisIsCloneSubOrMidWeightCom(analysisIsCloneSubOrMidWeightComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//virtualUsage M3接收克隆子或中周期出参  70093
      //ModelCode: receptionService
        ImplementSixReceivingFieldRespDto receptionServiceRes_2 = null;
    if(analysisIsCloneSubOrMidWeightComRespDto !=null){
          ImplementSixReceivingFieldReqDto receptionServiceReq_1=new ImplementSixReceivingFieldReqDto();
  if(analysisIsCloneSubOrMidWeightComRespDto!=null){
      receptionServiceReq_1.setCloneSubCycle(analysisIsCloneSubOrMidWeightComRespDto.getCloneSubCycle());//SimpleFieldAssign//sourceId:1871563_1_70093

    }

    /*M3接收克隆子或中周期出参[8635]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCloneSubCycle(),"D3分析是否只查看目标父周期(公共)-M3接收克隆子或中周期出参-克隆子或中周期不能为空",false);
      receptionServiceRes_2 = nbWeightTarget.implementSixReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
           }
AnalysisIsOnlyQueryTargetParentCycleComRespDto retData = new AnalysisIsOnlyQueryTargetParentCycleComRespDto();
  if(analysisHomozygousBetweenFatherAndSonComRespDto_1!=null){
      retData.setFatherMidSubCycleDataModel(analysisHomozygousBetweenFatherAndSonComRespDto_1.getFatherMidSubCycleDataModel());//SimpleFieldAssign//sourceId:1868493_1
    }
if(receptionServiceRes_3!=null){
      retData.setCloneSubCycle(receptionServiceRes_3.getCloneSubCycle());//SimpleFieldAssign//sourceId:1871564_1
    }
if(queryEvaObjTargetCyclePlatformDetailComRespDto_1!=null){
      retData.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1873928_1
    }




return retData;
  }
/**
   * D3查询上级父周期权重列表(公共)[9816]
   * gen by moon at 7/17/2024, 1:25:42 AM
   */
  @Trace(operationName = "D3查询上级父周期权重列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySuperiorParentCycleWeightListComRespDto querySuperiorParentCycleWeightListCom(QuerySuperiorParentCycleWeightListComReqDto reqDto){


      BatchQueryTargetCycleWeightComRespDto batchQueryTargetCycleWeightComRespDto_1 =null;
if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET")||reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_CATEGORY")||reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
        //if((D3查询上级父周期权重列表(公共).冗余内容表类型编码 等于 目标表 or D3查询上级父周期权重列表(公共).冗余内容表类型编码 等于 目标分类表 or D3查询上级父周期权重列表(公共).冗余内容表类型编码 等于 指标表))  70034

QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto = null;
    QueryEvaTargetCycleListComReqDto queryEvaTargetCycleListComReqDto=new QueryEvaTargetCycleListComReqDto();
  queryEvaTargetCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1869006_1_70036
queryEvaTargetCycleListComReqDto.setIsParentCycle("TRUE");//sourceId:1869008_1_70036
queryEvaTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1869010_1_70036
if(reqDto!=null){
      queryEvaTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1869007_1_70036
queryEvaTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1869009_1_70036
queryEvaTargetCycleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1869011_1_70036
    }

    /*D3查目标内容规划树父周期列表（用于批量查询权重入参）[9416]   */
    Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjTypeCode(),"D3查询上级父周期权重列表(公共)-D3查目标内容规划树父周期列表（用于批量查询权重入参）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getTargetCycleContentId(),"D3查询上级父周期权重列表(公共)-D3查目标内容规划树父周期列表（用于批量查询权重入参）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getIsParentCycle(),"D3查询上级父周期权重列表(公共)-D3查目标内容规划树父周期列表（用于批量查询权重入参）-是否父周期不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaluationTemplateId(),"D3查询上级父周期权重列表(公共)-D3查目标内容规划树父周期列表（用于批量查询权重入参）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getIsArchive(),"D3查询上级父周期权重列表(公共)-D3查目标内容规划树父周期列表（用于批量查询权重入参）-是否存档不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getSpaceId(),"D3查询上级父周期权重列表(公共)-D3查目标内容规划树父周期列表（用于批量查询权重入参）-创建于空间ID不能为空",false);
      queryEvaTargetCycleListComRespDto = targetContComService.queryEvaTargetCycleListCom(queryEvaTargetCycleListComReqDto)/*vcase invoke isSameApp*/;



if((queryEvaTargetCycleListComRespDto!= null&&  queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null && queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3查目标内容规划树父周期列表（用于批量查询权重入参）.被评对象目标周期列表数据集条数 大于 0)  70037

BatchQueryTargetCycleWeightComRespDto batchQueryTargetCycleWeightComRespDto = null;
    if(queryEvaTargetCycleListComRespDto !=null){
          BatchQueryTargetCycleWeightComReqDto batchQueryTargetCycleWeightComReqDto=new BatchQueryTargetCycleWeightComReqDto();
  batchQueryTargetCycleWeightComReqDto.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1869017_1_70038
if(queryEvaTargetCycleListComRespDto!= null&&  queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList())){
    batchQueryTargetCycleWeightComReqDto.setEvaObjTargetCycleList(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1869016_1_70038
    }
if(reqDto!=null){
      batchQueryTargetCycleWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1869018_1_70038
    }

    /*D3批量查询目标周期权重(公共)[9814]   */
    Assert.isNull(batchQueryTargetCycleWeightComReqDto.getParentSubMidCycleType(),"D3查询上级父周期权重列表(公共)-D3批量查询目标周期权重(公共)-父子中周期类型不能为空",false);
Assert.isNull(batchQueryTargetCycleWeightComReqDto.getEvaluationTemplateId(),"D3查询上级父周期权重列表(公共)-D3批量查询目标周期权重(公共)-冗余评价模板ID不能为空",false);
      batchQueryTargetCycleWeightComRespDto = batchQueryTargetCycleWeightCom(batchQueryTargetCycleWeightComReqDto)/*vcase invoke 同服务,同domain*/;


      batchQueryTargetCycleWeightComRespDto_1 = batchQueryTargetCycleWeightComRespDto;
           }
      }
      }
else if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_EVALUATION_OBJECT_TARGET_CYCLE"))){
       //elseif(D3查询上级父周期权重列表(公共).冗余内容表类型编码 等于 被评对象目标周期表)  70035

QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1869020_1_70039
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1869019_1_70039
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1869021_1_70039
queryEvaObjTargetCyclePlatformDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1869022_1_70039
    }

    /*D3查其他树目标周期详情(用于下文入参使用)[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(),"D3查询上级父周期权重列表(公共)-D3查其他树目标周期详情(用于下文入参使用)-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3查询上级父周期权重列表(公共)-D3查其他树目标周期详情(用于下文入参使用)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(),"D3查询上级父周期权重列表(公共)-D3查其他树目标周期详情(用于下文入参使用)-是否存档不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getSpaceId(),"D3查询上级父周期权重列表(公共)-D3查其他树目标周期详情(用于下文入参使用)-创建于空间ID不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;



QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto_2 = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          QueryEvaTargetCycleListComReqDto queryEvaTargetCycleListComReqDto_1=new QueryEvaTargetCycleListComReqDto();
  queryEvaTargetCycleListComReqDto_1.setIsParentCycle("TRUE");//sourceId:1869029_1_70040
queryEvaTargetCycleListComReqDto_1.setIsArchive("FALSE");//sourceId:1869031_1_70040
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      queryEvaTargetCycleListComReqDto_1.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1869026_1_70040
queryEvaTargetCycleListComReqDto_1.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1869027_1_70040
queryEvaTargetCycleListComReqDto_1.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1869028_1_70040
    }
if(reqDto!=null){
      queryEvaTargetCycleListComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1869030_1_70040
queryEvaTargetCycleListComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1869032_1_70040
    }

    /*D3查其他树目标内容目标父周期列表（用于批量查权重入参）[9416]   */
    Assert.isNull(queryEvaTargetCycleListComReqDto_1.getEvaObjEntityId(),"D3查询上级父周期权重列表(公共)-D3查其他树目标内容目标父周期列表（用于批量查权重入参）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto_1.getEvaObjTypeCode(),"D3查询上级父周期权重列表(公共)-D3查其他树目标内容目标父周期列表（用于批量查权重入参）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto_1.getTargetCycleContentId(),"D3查询上级父周期权重列表(公共)-D3查其他树目标内容目标父周期列表（用于批量查权重入参）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto_1.getIsParentCycle(),"D3查询上级父周期权重列表(公共)-D3查其他树目标内容目标父周期列表（用于批量查权重入参）-是否父周期不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto_1.getEvaluationTemplateId(),"D3查询上级父周期权重列表(公共)-D3查其他树目标内容目标父周期列表（用于批量查权重入参）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto_1.getIsArchive(),"D3查询上级父周期权重列表(公共)-D3查其他树目标内容目标父周期列表（用于批量查权重入参）-是否存档不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto_1.getSpaceId(),"D3查询上级父周期权重列表(公共)-D3查其他树目标内容目标父周期列表（用于批量查权重入参）-创建于空间ID不能为空",false);
      queryEvaTargetCycleListComRespDto_2 = targetContComService.queryEvaTargetCycleListCom(queryEvaTargetCycleListComReqDto_1)/*vcase invoke isSameApp*/;



           }
if((queryEvaTargetCycleListComRespDto_2!= null&&  queryEvaTargetCycleListComRespDto_2.getEvaObjTargetCycleList() !=null && queryEvaTargetCycleListComRespDto_2.getEvaObjTargetCycleList().size()>0)) {
        //if(D3查其他树目标内容目标父周期列表（用于批量查权重入参）.被评对象目标周期列表数据集条数 大于 0)  70041

BatchQueryTargetCycleWeightComRespDto batchQueryTargetCycleWeightComRespDto_2 = null;
    if(queryEvaTargetCycleListComRespDto_2 !=null){
          BatchQueryTargetCycleWeightComReqDto batchQueryTargetCycleWeightComReqDto_1=new BatchQueryTargetCycleWeightComReqDto();
  batchQueryTargetCycleWeightComReqDto_1.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1869017_1_70042
if(queryEvaTargetCycleListComRespDto_2!= null&&  queryEvaTargetCycleListComRespDto_2.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto_2.getEvaObjTargetCycleList())){
    batchQueryTargetCycleWeightComReqDto_1.setEvaObjTargetCycleList(queryEvaTargetCycleListComRespDto_2.getEvaObjTargetCycleList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1869016_1_70042
    }
if(reqDto!=null){
      batchQueryTargetCycleWeightComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1869018_1_70042
    }

    /*D3批量查询目标周期权重(公共)[9814]   */
    Assert.isNull(batchQueryTargetCycleWeightComReqDto_1.getParentSubMidCycleType(),"D3查询上级父周期权重列表(公共)-D3批量查询目标周期权重(公共)-父子中周期类型不能为空",false);
Assert.isNull(batchQueryTargetCycleWeightComReqDto_1.getEvaluationTemplateId(),"D3查询上级父周期权重列表(公共)-D3批量查询目标周期权重(公共)-冗余评价模板ID不能为空",false);
      batchQueryTargetCycleWeightComRespDto_2 = batchQueryTargetCycleWeightCom(batchQueryTargetCycleWeightComReqDto_1)/*vcase invoke 同服务,同domain*/;


      batchQueryTargetCycleWeightComRespDto_1 = batchQueryTargetCycleWeightComRespDto_2;
           }
      }
    }
QuerySuperiorParentCycleWeightListComRespDto retData = new QuerySuperiorParentCycleWeightListComRespDto();
  if(batchQueryTargetCycleWeightComRespDto_1!=null){
      retData.setEvaObjTargetCycleWeightList(batchQueryTargetCycleWeightComRespDto_1.getEvaObjTargetCycleWeightList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1869033_1
    }




return retData;
  }
/**
   * D3查询上级目标周期权重列表[9817]
   * gen by moon at 6/16/2024, 7:53:59 PM
   */
  @Trace(operationName = "D3查询上级目标周期权重列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySuperiorTargetCycleWeightListRespDto querySuperiorTargetCycleWeightList(QuerySuperiorTargetCycleWeightListReqDto reqDto){


      AnalysisIsOnlyQueryTargetParentCycleComRespDto analysisIsOnlyQueryTargetParentCycleComRespDto_1 =null;
ImplementFiveReceivingFieldRespDto receptionServiceRes_1 =null;
//virtualUsage D3分析是否只查看目标父周期(公共)  70043
      AnalysisIsOnlyQueryTargetParentCycleComRespDto analysisIsOnlyQueryTargetParentCycleComRespDto = null;
    AnalysisIsOnlyQueryTargetParentCycleComReqDto analysisIsOnlyQueryTargetParentCycleComReqDto=new AnalysisIsOnlyQueryTargetParentCycleComReqDto();
  if(reqDto!=null){
      analysisIsOnlyQueryTargetParentCycleComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1871364_1_70043
analysisIsOnlyQueryTargetParentCycleComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1871365_1_70043
analysisIsOnlyQueryTargetParentCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1869042_1_70043
analysisIsOnlyQueryTargetParentCycleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1869044_1_70043
    }

    /*D3分析是否只查看目标父周期(公共)[9815]   */
    Assert.isNull(analysisIsOnlyQueryTargetParentCycleComReqDto.getTableTypeCode(),"D3查询上级目标周期权重列表-D3分析是否只查看目标父周期(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(analysisIsOnlyQueryTargetParentCycleComReqDto.getEntityId(),"D3查询上级目标周期权重列表-D3分析是否只查看目标父周期(公共)-冗余内容表主键ID不能为空",false);
Assert.isNull(analysisIsOnlyQueryTargetParentCycleComReqDto.getEvaluationTemplateId(),"D3查询上级目标周期权重列表-D3分析是否只查看目标父周期(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(analysisIsOnlyQueryTargetParentCycleComReqDto.getSpaceId(),"D3查询上级目标周期权重列表-D3分析是否只查看目标父周期(公共)-创建于空间ID不能为空",false);
      analysisIsOnlyQueryTargetParentCycleComRespDto = analysisIsOnlyQueryTargetParentCycleCom(analysisIsOnlyQueryTargetParentCycleComReqDto)/*vcase invoke 同服务,同domain*/;


      analysisIsOnlyQueryTargetParentCycleComRespDto_1 = analysisIsOnlyQueryTargetParentCycleComRespDto;
if((analysisIsOnlyQueryTargetParentCycleComRespDto!= null&&  analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel() !=null && analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel().equals("FATHER_MID_SUB_SAME")||analysisIsOnlyQueryTargetParentCycleComRespDto!= null&&  analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel() !=null && analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel().equals("FATHER_SUB_SAME"))&&(analysisIsOnlyQueryTargetParentCycleComRespDto!= null&&  analysisIsOnlyQueryTargetParentCycleComRespDto.getCloneSubCycle() !=null && analysisIsOnlyQueryTargetParentCycleComRespDto.getCloneSubCycle().equals("1"))) {
        //if((D3分析是否只查看目标父周期(公共).父子中周期数据同体模型 等于 父子中同体 or D3分析是否只查看目标父周期(公共).父子中周期数据同体模型 等于 父子同体) and D3分析是否只查看目标父周期(公共).克隆子或中周期 等于 1)  70045

QuerySuperiorParentCycleWeightListComRespDto querySuperiorParentCycleWeightListComRespDto = null;
    QuerySuperiorParentCycleWeightListComReqDto querySuperiorParentCycleWeightListComReqDto=new QuerySuperiorParentCycleWeightListComReqDto();
  if(reqDto!=null){
      querySuperiorParentCycleWeightListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1869036_1_70047
querySuperiorParentCycleWeightListComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1869037_1_70047
querySuperiorParentCycleWeightListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1869038_1_70047
querySuperiorParentCycleWeightListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1869039_1_70047
    }

    /*D3查询上级父周期权重列表(公共)[9816]   */
    Assert.isNull(querySuperiorParentCycleWeightListComReqDto.getTableTypeCode(),"D3查询上级目标周期权重列表-D3查询上级父周期权重列表(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(querySuperiorParentCycleWeightListComReqDto.getEntityId(),"D3查询上级目标周期权重列表-D3查询上级父周期权重列表(公共)-冗余内容表主键ID不能为空",false);
Assert.isNull(querySuperiorParentCycleWeightListComReqDto.getEvaluationTemplateId(),"D3查询上级目标周期权重列表-D3查询上级父周期权重列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(querySuperiorParentCycleWeightListComReqDto.getSpaceId(),"D3查询上级目标周期权重列表-D3查询上级父周期权重列表(公共)-创建于空间ID不能为空",false);
      querySuperiorParentCycleWeightListComRespDto = querySuperiorParentCycleWeightListCom(querySuperiorParentCycleWeightListComReqDto)/*vcase invoke 同服务,同domain*/;



//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    if(querySuperiorParentCycleWeightListComRespDto !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  if(querySuperiorParentCycleWeightListComRespDto!= null&&  querySuperiorParentCycleWeightListComRespDto.getEvaObjTargetCycleWeightList() !=null&& !CollectionUtil.isEmpty(querySuperiorParentCycleWeightListComRespDto.getEvaObjTargetCycleWeightList())){
      receptionServiceReq.setEvaObjTargetCycleWeightList(querySuperiorParentCycleWeightListComRespDto.getEvaObjTargetCycleWeightList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1869858_1_70056
    }

    /*M3接收权重权重分出参[8467]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbWeightTarget.implementFiveReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((!(analysisIsOnlyQueryTargetParentCycleComRespDto!= null&&  analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel() !=null && analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel().equals("FATHER_MID_SUB_SAME")))||(!(analysisIsOnlyQueryTargetParentCycleComRespDto!= null&&  analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel() !=null && analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel().equals("FATHER_SUB_SAME")))||(analysisIsOnlyQueryTargetParentCycleComRespDto!= null&&  analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel() !=null && analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel().equals("FATHER_MID_SUB_SAME")&&analysisIsOnlyQueryTargetParentCycleComRespDto!= null&&  analysisIsOnlyQueryTargetParentCycleComRespDto.getCloneSubCycle() !=null && analysisIsOnlyQueryTargetParentCycleComRespDto.getCloneSubCycle().equals("0"))||(analysisIsOnlyQueryTargetParentCycleComRespDto!= null&&  analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel() !=null && analysisIsOnlyQueryTargetParentCycleComRespDto.getFatherMidSubCycleDataModel().equals("FATHER_SUB_SAME")&&analysisIsOnlyQueryTargetParentCycleComRespDto!= null&&  analysisIsOnlyQueryTargetParentCycleComRespDto.getCloneSubCycle() !=null && analysisIsOnlyQueryTargetParentCycleComRespDto.getCloneSubCycle().equals("0"))){
       //elseif(D3分析是否只查看目标父周期(公共).父子中周期数据同体模型 不等于 父子中同体 or D3分析是否只查看目标父周期(公共).父子中周期数据同体模型 不等于 父子同体 or (D3分析是否只查看目标父周期(公共).父子中周期数据同体模型 等于 父子中同体 and D3分析是否只查看目标父周期(公共).克隆子或中周期 等于 0) or (D3分析是否只查看目标父周期(公共).父子中周期数据同体模型 等于 父子同体 and D3分析是否只查看目标父周期(公共).克隆子或中周期 等于 0))  70046

QuerySuperiorTargetFullCycleListComRespDto querySuperiorTargetFullCycleListComRespDto = null;
    QuerySuperiorTargetFullCycleListComReqDto querySuperiorTargetFullCycleListComReqDto=new QuerySuperiorTargetFullCycleListComReqDto();
  if(reqDto!=null){
      querySuperiorTargetFullCycleListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1869046_1_70048
querySuperiorTargetFullCycleListComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1869047_1_70048
querySuperiorTargetFullCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1869048_1_70048
querySuperiorTargetFullCycleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1869049_1_70048
    }

    /*D3查询上级目标全周期权重列表(公共)[9813]   */
    Assert.isNull(querySuperiorTargetFullCycleListComReqDto.getTableTypeCode(),"D3查询上级目标周期权重列表-D3查询上级目标全周期权重列表(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(querySuperiorTargetFullCycleListComReqDto.getEntityId(),"D3查询上级目标周期权重列表-D3查询上级目标全周期权重列表(公共)-冗余内容表主键ID不能为空",false);
Assert.isNull(querySuperiorTargetFullCycleListComReqDto.getEvaluationTemplateId(),"D3查询上级目标周期权重列表-D3查询上级目标全周期权重列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(querySuperiorTargetFullCycleListComReqDto.getSpaceId(),"D3查询上级目标周期权重列表-D3查询上级目标全周期权重列表(公共)-创建于空间ID不能为空",false);
      querySuperiorTargetFullCycleListComRespDto = querySuperiorTargetFullCycleListCom(querySuperiorTargetFullCycleListComReqDto)/*vcase invoke 同服务,同domain*/;



//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
    if(querySuperiorTargetFullCycleListComRespDto !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  if(querySuperiorTargetFullCycleListComRespDto!= null&&  querySuperiorTargetFullCycleListComRespDto.getEvaObjTargetCycleWeightList() !=null&& !CollectionUtil.isEmpty(querySuperiorTargetFullCycleListComRespDto.getEvaObjTargetCycleWeightList())){
      receptionServiceReq_1.setEvaObjTargetCycleWeightList(querySuperiorTargetFullCycleListComRespDto.getEvaObjTargetCycleWeightList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1869858_1_70058
    }

    /*M3接收权重权重分出参[8467]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbWeightTarget.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
QuerySuperiorTargetCycleWeightListRespDto retData = new QuerySuperiorTargetCycleWeightListRespDto();
  if(receptionServiceRes_1!=null){
      retData.setEvaObjTargetCycleWeightList(receptionServiceRes_1.getEvaObjTargetCycleWeightList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1871380_1
    }
if(analysisIsOnlyQueryTargetParentCycleComRespDto_1!=null){
      retData.setCloneSubCycle(analysisIsOnlyQueryTargetParentCycleComRespDto_1.getCloneSubCycle());//SimpleFieldAssign//sourceId:1871566_1
retData.setEvaObjTypeCode(analysisIsOnlyQueryTargetParentCycleComRespDto_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1873930_1
    }




return retData;
  }
/**
   * D3分析被评对象内容表主键ID(公共)[9818]
   * gen by moon at 6/16/2024, 3:06:53 AM
   */
  @Trace(operationName = "D3分析被评对象内容表主键ID(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisEvaObjEntityIdComRespDto analysisEvaObjEntityIdCom(AnalysisEvaObjEntityIdComReqDto reqDto){


      ImplementFiveReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET")||reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_CATEGORY")||reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
        //if((D3分析被评对象内容表主键ID(公共).冗余内容表类型编码 等于 目标表 or D3分析被评对象内容表主键ID(公共).冗余内容表类型编码 等于 目标分类表 or D3分析被评对象内容表主键ID(公共).冗余内容表类型编码 等于 指标表))  70051

//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjEntityId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1871273_1_70053
receptionServiceReq.setTargetCycleContentId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1871359_1_70053
    }

    /*M3接收被评对象内容表主键出参[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjEntityId(),"D3分析被评对象内容表主键ID(公共)-M3接收被评对象内容表主键出参-被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3分析被评对象内容表主键ID(公共)-M3接收被评对象内容表主键出参-关联目标内容ID不能为空",false);
      receptionServiceRes = nbWeightTarget.implementFiveReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
      }
else if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_EVALUATION_OBJECT_TARGET_CYCLE"))){
       //elseif(D3分析被评对象内容表主键ID(公共).冗余内容表类型编码 等于 被评对象目标周期表)  70052

QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1871349_1_70054
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1871350_1_70054
queryEvaObjTargetCyclePlatformDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1871351_1_70054
    }

    /*D3查询被评对象目标周期详请[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(),"D3分析被评对象内容表主键ID(公共)-D3查询被评对象目标周期详请-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3分析被评对象内容表主键ID(公共)-D3查询被评对象目标周期详请-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getSpaceId(),"D3分析被评对象内容表主键ID(公共)-D3查询被评对象目标周期详请-创建于空间ID不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      receptionServiceReq_1.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1871273_1_70055
receptionServiceReq_1.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1871359_1_70055
    }

    /*M3接收被评对象内容表主键出参[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getEvaObjEntityId(),"D3分析被评对象内容表主键ID(公共)-M3接收被评对象内容表主键出参-被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq_1.getTargetCycleContentId(),"D3分析被评对象内容表主键ID(公共)-M3接收被评对象内容表主键出参-关联目标内容ID不能为空",false);
      receptionServiceRes_2 = nbWeightTarget.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
AnalysisEvaObjEntityIdComRespDto retData = new AnalysisEvaObjEntityIdComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setEvaObjEntityId(receptionServiceRes_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1871352_1
retData.setTargetCycleContentId(receptionServiceRes_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1871362_1
    }




return retData;
  }
/**
   * D3查询下级目标周期权重列表(公共)[9819]
   * gen by moon at 7/17/2024, 1:25:45 AM
   */
  @Trace(operationName = "D3查询下级目标周期权重列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySubordinateTargetCycleWeightListComRespDto querySubordinateTargetCycleWeightListCom(QuerySubordinateTargetCycleWeightListComReqDto reqDto){


      BatchQueryTargetCycleWeightComRespDto batchQueryTargetCycleWeightComRespDto_1 =null;
//virtualUsage D3查询上级目标周期详请（用于查下级目标周期入参）  70069
      QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1872061_1_70069
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getSuperiorEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1872060_1_70069
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1872062_1_70069
queryEvaObjTargetCyclePlatformDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1872063_1_70069
    }

    /*D3查询上级目标周期详请（用于查下级目标周期入参）[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(),"D3查询下级目标周期权重列表(公共)-D3查询上级目标周期详请（用于查下级目标周期入参）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(),"D3查询下级目标周期权重列表(公共)-D3查询上级目标周期详请（用于查下级目标周期入参）-是否存档不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3查询下级目标周期权重列表(公共)-D3查询上级目标周期详请（用于查下级目标周期入参）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getSpaceId(),"D3查询下级目标周期权重列表(公共)-D3查询上级目标周期详请（用于查下级目标周期入参）-创建于空间ID不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3执行转单字段父子中周期类型(公共)  70071
      ImplementTurnSingleFieldParentSubMidCycleTypeComRespDto implementTurnSingleFieldParentSubMidCycleTypeComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          ImplementTurnSingleFieldParentSubMidCycleTypeComReqDto implementTurnSingleFieldParentSubMidCycleTypeComReqDto=new ImplementTurnSingleFieldParentSubMidCycleTypeComReqDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      implementTurnSingleFieldParentSubMidCycleTypeComReqDto.setCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleId());//SimpleFieldAssign//sourceId:1872097_1_70071
    }
if(reqDto!=null){
      implementTurnSingleFieldParentSubMidCycleTypeComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1872092_1_70071
    }

    /*D3执行转单字段父子中周期类型(公共)[9319]   */
    Assert.isNull(implementTurnSingleFieldParentSubMidCycleTypeComReqDto.getCycleId(),"D3查询下级目标周期权重列表(公共)-D3执行转单字段父子中周期类型(公共)-周期ID不能为空",false);
Assert.isNull(implementTurnSingleFieldParentSubMidCycleTypeComReqDto.getParentSubMidCycleType(),"D3查询下级目标周期权重列表(公共)-D3执行转单字段父子中周期类型(公共)-父子中周期类型不能为空",false);
      implementTurnSingleFieldParentSubMidCycleTypeComRespDto = dashboardTargetContentService.implementTurnSingleFieldParentSubMidCycleTypeCom(implementTurnSingleFieldParentSubMidCycleTypeComReqDto)/*vcase invoke isSameApp*/;



           }
//virtualUsage D3查询下级目标周期列表(公共)  70070
      QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null&&implementTurnSingleFieldParentSubMidCycleTypeComRespDto !=null){
          QueryEvaTargetCycleListComReqDto queryEvaTargetCycleListComReqDto=new QueryEvaTargetCycleListComReqDto();
  queryEvaTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1872090_1_70070
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      queryEvaTargetCycleListComReqDto.setParentEvaObjTargetCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1872082_1_70070
queryEvaTargetCycleListComReqDto.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1872083_1_70070
queryEvaTargetCycleListComReqDto.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1872084_1_70070
    }
if(implementTurnSingleFieldParentSubMidCycleTypeComRespDto!=null){
      queryEvaTargetCycleListComReqDto.setCycleId(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1872085_1_70070
queryEvaTargetCycleListComReqDto.setIsParentCycle(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1872086_1_70070
queryEvaTargetCycleListComReqDto.setIsMetaphase(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1872087_1_70070
queryEvaTargetCycleListComReqDto.setIsSubCycle(implementTurnSingleFieldParentSubMidCycleTypeComRespDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1872088_1_70070
    }
if(reqDto!=null){
      queryEvaTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1872089_1_70070
queryEvaTargetCycleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1872091_1_70070
    }

    /*D3查询下级目标周期列表(公共)[9416]   */
    Assert.isNull(queryEvaTargetCycleListComReqDto.getParentEvaObjTargetCycleId(),"D3查询下级目标周期权重列表(公共)-D3查询下级目标周期列表(公共)-上级被评对象目标周期标识不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjEntityId(),"D3查询下级目标周期权重列表(公共)-D3查询下级目标周期列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjTypeCode(),"D3查询下级目标周期权重列表(公共)-D3查询下级目标周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaluationTemplateId(),"D3查询下级目标周期权重列表(公共)-D3查询下级目标周期列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getIsArchive(),"D3查询下级目标周期权重列表(公共)-D3查询下级目标周期列表(公共)-是否存档不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getSpaceId(),"D3查询下级目标周期权重列表(公共)-D3查询下级目标周期列表(公共)-创建于空间ID不能为空",false);
      queryEvaTargetCycleListComRespDto = targetContComService.queryEvaTargetCycleListCom(queryEvaTargetCycleListComReqDto)/*vcase invoke isSameApp*/;



           }
//virtualUsage D3批量查询目标周期权重(公共)  70072
      BatchQueryTargetCycleWeightComRespDto batchQueryTargetCycleWeightComRespDto = null;
    if(queryEvaTargetCycleListComRespDto !=null){
          BatchQueryTargetCycleWeightComReqDto batchQueryTargetCycleWeightComReqDto=new BatchQueryTargetCycleWeightComReqDto();
  if(queryEvaTargetCycleListComRespDto!= null&&  queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList())){
      batchQueryTargetCycleWeightComReqDto.setEvaObjTargetCycleList(queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1872098_1_70072
    }
if(reqDto!=null){
      batchQueryTargetCycleWeightComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1872100_1_70072
batchQueryTargetCycleWeightComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1872101_1_70072
    }

    /*D3批量查询目标周期权重(公共)[9814]   */
    Assert.isNull(batchQueryTargetCycleWeightComReqDto.getParentSubMidCycleType(),"D3查询下级目标周期权重列表(公共)-D3批量查询目标周期权重(公共)-父子中周期类型不能为空",false);
Assert.isNull(batchQueryTargetCycleWeightComReqDto.getEvaluationTemplateId(),"D3查询下级目标周期权重列表(公共)-D3批量查询目标周期权重(公共)-冗余评价模板ID不能为空",false);
      batchQueryTargetCycleWeightComRespDto = batchQueryTargetCycleWeightCom(batchQueryTargetCycleWeightComReqDto)/*vcase invoke 同服务,同domain*/;


      batchQueryTargetCycleWeightComRespDto_1 = batchQueryTargetCycleWeightComRespDto;
           }
QuerySubordinateTargetCycleWeightListComRespDto retData = new QuerySubordinateTargetCycleWeightListComRespDto();
  if(batchQueryTargetCycleWeightComRespDto_1!=null){
      retData.setEvaObjTargetCycleWeightList(batchQueryTargetCycleWeightComRespDto_1.getEvaObjTargetCycleWeightList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleWeightDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1872109_1
    }




return retData;
  }
/**
   * D3查询下级目标周期权重列表[9821]
   * gen by moon at 6/16/2024, 3:07:32 AM
   */
  @Trace(operationName = "D3查询下级目标周期权重列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySubordinateTargetCycleWeightListRespDto querySubordinateTargetCycleWeightList(QuerySubordinateTargetCycleWeightListReqDto reqDto){


      QuerySubordinateTargetCycleWeightListComRespDto querySubordinateTargetCycleWeightListComRespDto_1 =null;
List<OmsVirtualOrgMember> listOmsVirtualOrgMember_1 =new ArrayList<>();
List<OmsVirtualOrgMemberDept> listOmsVirtualOrgMemberDept_1 =new ArrayList<>();
//步骤0: D3查询下级目标周期权重列表(公共) - querySubordinateTargetCycleWeightListCom
     QuerySubordinateTargetCycleWeightListComRespDto querySubordinateTargetCycleWeightListComRespDto = null;
    QuerySubordinateTargetCycleWeightListComReqDto querySubordinateTargetCycleWeightListComReqDto=new QuerySubordinateTargetCycleWeightListComReqDto();
  if(reqDto!=null){
      querySubordinateTargetCycleWeightListComReqDto.setSuperiorEvaObjTargetCycleId(reqDto.getSuperiorEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1872111_1
querySubordinateTargetCycleWeightListComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1872112_1
querySubordinateTargetCycleWeightListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1872113_1
querySubordinateTargetCycleWeightListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1872114_1
    }

    /*D3查询下级目标周期权重列表(公共)[9819]   */
    Assert.isNull(querySubordinateTargetCycleWeightListComReqDto.getSuperiorEvaObjTargetCycleId(),"D3查询下级目标周期权重列表-D3查询下级目标周期权重列表(公共)-上级被评对象目标周期ID不能为空",false);
Assert.isNull(querySubordinateTargetCycleWeightListComReqDto.getParentSubMidCycleType(),"D3查询下级目标周期权重列表-D3查询下级目标周期权重列表(公共)-父子中周期类型不能为空",false);
Assert.isNull(querySubordinateTargetCycleWeightListComReqDto.getEvaluationTemplateId(),"D3查询下级目标周期权重列表-D3查询下级目标周期权重列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(querySubordinateTargetCycleWeightListComReqDto.getSpaceId(),"D3查询下级目标周期权重列表-D3查询下级目标周期权重列表(公共)-创建于空间ID不能为空",false);
      querySubordinateTargetCycleWeightListComRespDto = querySubordinateTargetCycleWeightListCom(querySubordinateTargetCycleWeightListComReqDto)/*vcase invoke 同服务,同domain*/;


      querySubordinateTargetCycleWeightListComRespDto_1 = querySubordinateTargetCycleWeightListComRespDto;

//步骤1: 3-6-02批量查虚拟组织成员 - batchQueryVirtualOrgMember
     List<OmsVirtualOrgMember> listOmsVirtualOrgMember =new ArrayList<>();
    if(querySubordinateTargetCycleWeightListComRespDto !=null){
          BatchQueryVirtualOrgMemberReq batchQueryVirtualOrgMemberReq=new BatchQueryVirtualOrgMemberReq();
  batchQueryVirtualOrgMemberReq.setIsPersonCharge("TRUE");//sourceId:1872152_1
batchQueryVirtualOrgMemberReq.setIsArchive("FALSE");//sourceId:1872154_1
if(querySubordinateTargetCycleWeightListComRespDto!= null&&  querySubordinateTargetCycleWeightListComRespDto.getEvaObjTargetCycleWeightList() !=null&& !CollectionUtil.isEmpty(querySubordinateTargetCycleWeightListComRespDto.getEvaObjTargetCycleWeightList())){
      batchQueryVirtualOrgMemberReq.setVirtualOrgMemberList(querySubordinateTargetCycleWeightListComRespDto.getEvaObjTargetCycleWeightList().stream().map(item->item.getTargetCycleContentId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1872151_1
    }
if(reqDto!=null){
      batchQueryVirtualOrgMemberReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1872153_1
    }

    /*3-6-02批量查虚拟组织成员[2672]   */
    Assert.isNull(batchQueryVirtualOrgMemberReq.getIsPersonCharge(),"D3查询下级目标周期权重列表-3-6-02批量查虚拟组织成员-是否负责人不能为空",false);
Assert.isNull(batchQueryVirtualOrgMemberReq.getEvaluationTemplateId(),"D3查询下级目标周期权重列表-3-6-02批量查虚拟组织成员-归属对象ID不能为空",false);
Assert.isNull(batchQueryVirtualOrgMemberReq.getIsArchive(),"D3查询下级目标周期权重列表-3-6-02批量查虚拟组织成员-是否存档不能为空",false);
      listOmsVirtualOrgMember = mOmsVirtualOrgMemberService.batchQueryVirtualOrgMember(batchQueryVirtualOrgMemberReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsVirtualOrgMember_1 = listOmsVirtualOrgMember;
           }

//步骤2: 3-6-03批量查虚拟成员部门 - batchQueryVirtualOrgMemberDept
     List<OmsVirtualOrgMemberDept> listOmsVirtualOrgMemberDept =new ArrayList<>();
    if(querySubordinateTargetCycleWeightListComRespDto !=null){
          BatchQueryVirtualOrgMemberDeptReq batchQueryVirtualOrgMemberDeptReq=new BatchQueryVirtualOrgMemberDeptReq();
  //todo dong 未找到匹配生成策略,请检查生成策略batchQueryVirtualOrgMemberDeptReq.setVirtualOrgMemberDeptList(querySubordinateTargetCycleWeightListComRespDto.getEvaObjTargetCycleWeightList()),数据源项; to( ==>tableName:undefined, fieldEnname:virtualOrgMemberDeptList ,uniqueId: 1872135_1 uniqueSourceId:1872115_1) from (varName:undefined fieldquerySubordinateTargetCycleWeightListComRespDto.getEvaObjTargetCycleWeightList())
batchQueryVirtualOrgMemberDeptReq.setIsArchive("FALSE");//sourceId:1872156_1
if(reqDto!=null){
      batchQueryVirtualOrgMemberDeptReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1872146_1
    }

    /*3-6-03批量查虚拟成员部门[2647]   */
    Assert.isNull(batchQueryVirtualOrgMemberDeptReq.getEvaluationTemplateId(),"D3查询下级目标周期权重列表-3-6-03批量查虚拟成员部门-归属对象ID不能为空",false);
Assert.isNull(batchQueryVirtualOrgMemberDeptReq.getIsArchive(),"D3查询下级目标周期权重列表-3-6-03批量查虚拟成员部门-是否存档不能为空",false);
      listOmsVirtualOrgMemberDept = mOmsVirtualOrgMemberDeptService.batchQueryVirtualOrgMemberDept(batchQueryVirtualOrgMemberDeptReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsVirtualOrgMemberDept_1 = listOmsVirtualOrgMemberDept;
           }

QuerySubordinateTargetCycleWeightListRespDto retData = new QuerySubordinateTargetCycleWeightListRespDto();
  //数据集融合  MoreListToOneSource
        if(querySubordinateTargetCycleWeightListComRespDto_1!= null && !CollectionUtil.isEmpty(querySubordinateTargetCycleWeightListComRespDto_1.getEvaObjTargetCycleWeightList()) ){
          for (EvaObjTargetCycleWeightDto evaObjTargetCycleWeightDto : querySubordinateTargetCycleWeightListComRespDto_1.getEvaObjTargetCycleWeightList()) {
              EvaObjTargetCycleWeightDto retElm = new EvaObjTargetCycleWeightDto();
             if(querySubordinateTargetCycleWeightListComRespDto_1!=null){
      retElm.setObjTargetCycleWeightSetId(evaObjTargetCycleWeightDto.getObjTargetCycleWeightSetId());//SimpleFieldAssign//sourceId:374389_2
retElm.setEvaObjTargetCycleId(evaObjTargetCycleWeightDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:374390_2
retElm.setCyclelAlias(evaObjTargetCycleWeightDto.getCyclelAlias());//SimpleFieldAssign//sourceId:374391_2
retElm.setTargetCycleName(evaObjTargetCycleWeightDto.getTargetCycleName());//SimpleFieldAssign//sourceId:374392_2
retElm.setParentSubMidCycleType(evaObjTargetCycleWeightDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:374393_2
retElm.setCycleId(evaObjTargetCycleWeightDto.getCycleId());//SimpleFieldAssign//sourceId:374394_2
retElm.setCycleStandardName(evaObjTargetCycleWeightDto.getCycleStandardName());//SimpleFieldAssign//sourceId:374395_2
retElm.setTargetCycleContentId(evaObjTargetCycleWeightDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:374396_2
retElm.setWeightValue(evaObjTargetCycleWeightDto.getWeightValue());//SimpleFieldAssign//sourceId:374397_2
retElm.setWeightScore(evaObjTargetCycleWeightDto.getWeightScore());//SimpleFieldAssign//sourceId:374398_2
    }
              retData.getEvaObjTargetCycleWeightList().add(retElm);
               if(listOmsVirtualOrgMember_1!= null&& !CollectionUtil.isEmpty(listOmsVirtualOrgMember_1)){
          for (OmsVirtualOrgMember omsVirtualOrgMember : listOmsVirtualOrgMember_1) {
                if (omsVirtualOrgMember.getEntityId().equals(evaObjTargetCycleWeightDto.getTargetCycleContentId())) {
                 retElm.setVirtualOrgInductionRecordId(omsVirtualOrgMember.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:374399_2
                }
            }
          }

 if(listOmsVirtualOrgMemberDept_1!= null&& !CollectionUtil.isEmpty(listOmsVirtualOrgMemberDept_1)){
          for (OmsVirtualOrgMemberDept omsVirtualOrgMemberDept : listOmsVirtualOrgMemberDept_1) {
                if (omsVirtualOrgMemberDept.getEntityId().equals(evaObjTargetCycleWeightDto.getTargetCycleContentId())) {
                 retElm.setDeptId(omsVirtualOrgMemberDept.getDeptId());//SimpleFieldAssign//sourceId:374400_2
                }
            }
          }

          }
        }//sourceId:1872157_1




return retData;
  }
/**
   * D3分析是否克隆子或中期权重(公共)[9822]
   * gen by moon at 6/16/2024, 3:07:48 AM
   */
  @Trace(operationName = "D3分析是否克隆子或中期权重(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisIsCloneSubOrMidWeightComRespDto analysisIsCloneSubOrMidWeightCom(AnalysisIsCloneSubOrMidWeightComReqDto reqDto){


      ImplementSixReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M3接收入参字段  70083
      //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("0");//CUSTOM_CONVENTION//sourceId:1872950_1_70083
receptionServiceReq.setCustomField2("1");//CUSTOM_CONVENTION//sourceId:1872951_1_70083
if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1872767_1_70083
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1872766_1_70083
receptionServiceReq.setFatherMidSubCycleDataModel(reqDto.getFatherMidSubCycleDataModel());//SimpleFieldAssign//sourceId:1872768_1_70083
    }

    /*M3接收入参字段[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3分析是否克隆子或中期权重(公共)-M3接收入参字段-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3分析是否克隆子或中期权重(公共)-M3接收入参字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getFatherMidSubCycleDataModel(),"D3分析是否克隆子或中期权重(公共)-M3接收入参字段-父子中周期数据同体模型不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField1(),"D3分析是否克隆子或中期权重(公共)-M3接收入参字段-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3分析是否克隆子或中期权重(公共)-M3接收入参字段-自定义字段2不能为空",false);
      receptionServiceRes = nbWeightTarget.implementFiveReceivingField(receptionServiceReq);



//virtualUsage 3-3-09-02查目标父周期权重  70079
      OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet = null;
    QueryEvaObjTargetCycleWeightDetailReq queryEvaObjTargetCycleWeightDetailReq=new QueryEvaObjTargetCycleWeightDetailReq();
  queryEvaObjTargetCycleWeightDetailReq.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1872713_1_70079
queryEvaObjTargetCycleWeightDetailReq.setIsArchive("FALSE");//sourceId:1872715_1_70079
if(reqDto!=null){
      queryEvaObjTargetCycleWeightDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1872712_1_70079
queryEvaObjTargetCycleWeightDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1872714_1_70079
    }

    /*3-3-09-02查目标父周期权重[2649]   */
    Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getEvaObjTargetCycleId(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标父周期权重-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getParentSubMidCycleType(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标父周期权重-父子中周期类型不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getEvaluationTemplateId(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标父周期权重-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getIsArchive(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标父周期权重-是否存档不能为空",false);
      omsEvaObjTargetCycleWeightSet = mOmsEvaObjTargetCycleWeightSetService.queryEvaObjTargetCycleWeightDetail(queryEvaObjTargetCycleWeightDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaObjTargetCycleWeightSet!= null&& omsEvaObjTargetCycleWeightSet.getWeightScore() != null )&&(reqDto!= null&&  reqDto.getFatherMidSubCycleDataModel() !=null && reqDto.getFatherMidSubCycleDataModel().equals("FATHER_MID_SUB_SAME")||reqDto!= null&&  reqDto.getFatherMidSubCycleDataModel() !=null && reqDto.getFatherMidSubCycleDataModel().equals("FATHER_SUB_SAME"))) {
        //if(3-3-09-02查目标父周期权重.权重分值 值不等于空  and (D3分析是否克隆子或中期权重(公共).父子中周期数据同体模型 等于 父子中同体 or D3分析是否克隆子或中期权重(公共).父子中周期数据同体模型 等于 父子同体))  70078

OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet_2 = null;
    if(omsEvaObjTargetCycleWeightSet !=null){
          QueryEvaObjTargetCycleWeightDetailReq queryEvaObjTargetCycleWeightDetailReq_1=new QueryEvaObjTargetCycleWeightDetailReq();
  queryEvaObjTargetCycleWeightDetailReq_1.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1872740_1_70080
queryEvaObjTargetCycleWeightDetailReq_1.setIsArchive("FALSE");//sourceId:1872739_1_70080
if(reqDto!=null){
      queryEvaObjTargetCycleWeightDetailReq_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1872736_1_70080
queryEvaObjTargetCycleWeightDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1872738_1_70080
    }
if(omsEvaObjTargetCycleWeightSet!=null){
      queryEvaObjTargetCycleWeightDetailReq_1.setWeightScore(omsEvaObjTargetCycleWeightSet.getWeightScore());//SimpleFieldAssign//sourceId:1872772_1_70080
    }

    /*3-3-09-02查目标子周期权重[2649]   */
    Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_1.getEvaObjTargetCycleId(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标子周期权重-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_1.getWeightScore(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标子周期权重-权重分值不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_1.getParentSubMidCycleType(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标子周期权重-父子中周期类型不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_1.getEvaluationTemplateId(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标子周期权重-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_1.getIsArchive(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标子周期权重-是否存档不能为空",false);
      omsEvaObjTargetCycleWeightSet_2 = mOmsEvaObjTargetCycleWeightSetService.queryEvaObjTargetCycleWeightDetail(queryEvaObjTargetCycleWeightDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet_4 = null;
    if(omsEvaObjTargetCycleWeightSet !=null){
          QueryEvaObjTargetCycleWeightDetailReq queryEvaObjTargetCycleWeightDetailReq_2=new QueryEvaObjTargetCycleWeightDetailReq();
  queryEvaObjTargetCycleWeightDetailReq_2.setParentSubMidCycleType("MID_CYCLE");//sourceId:1872762_1_70081
queryEvaObjTargetCycleWeightDetailReq_2.setIsArchive("FALSE");//sourceId:1872764_1_70081
if(reqDto!=null){
      queryEvaObjTargetCycleWeightDetailReq_2.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1872760_1_70081
queryEvaObjTargetCycleWeightDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1872763_1_70081
    }
if(omsEvaObjTargetCycleWeightSet!=null){
      queryEvaObjTargetCycleWeightDetailReq_2.setWeightScore(omsEvaObjTargetCycleWeightSet.getWeightScore());//SimpleFieldAssign//sourceId:1872761_1_70081
    }

    /*3-3-09-02查目标中期权重[2649]   */
    Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_2.getEvaObjTargetCycleId(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标中期权重-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_2.getWeightScore(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标中期权重-权重分值不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_2.getParentSubMidCycleType(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标中期权重-父子中周期类型不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_2.getEvaluationTemplateId(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标中期权重-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq_2.getIsArchive(),"D3分析是否克隆子或中期权重(公共)-3-3-09-02查目标中期权重-是否存档不能为空",false);
      omsEvaObjTargetCycleWeightSet_4 = mOmsEvaObjTargetCycleWeightSetService.queryEvaObjTargetCycleWeightDetail(queryEvaObjTargetCycleWeightDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



           }
if((reqDto!= null&&  reqDto.getFatherMidSubCycleDataModel() !=null && reqDto.getFatherMidSubCycleDataModel().equals("FATHER_MID_SUB_SAME")&&omsEvaObjTargetCycleWeightSet_2 != null &&omsEvaObjTargetCycleWeightSet_4 != null )||(reqDto!= null&&  reqDto.getFatherMidSubCycleDataModel() !=null && reqDto.getFatherMidSubCycleDataModel().equals("FATHER_SUB_SAME")&&omsEvaObjTargetCycleWeightSet_2 != null )) {
        //if((D3分析是否克隆子或中期权重(公共).父子中周期数据同体模型 等于 父子中同体 and 3-3-09-02查目标子周期权重.出参 值不等于空  and 3-3-09-02查目标中期权重.出参 值不等于空 ) or (D3分析是否克隆子或中期权重(公共).父子中周期数据同体模型 等于 父子同体 and 3-3-09-02查目标子周期权重.出参 值不等于空 ))  70082

//ModelCode: receptionService
        ImplementSixReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementSixReceivingFieldReqDto receptionServiceReq_1=new ImplementSixReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setCloneSubCycle(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1872954_1_70084
    }

    /*M3接收克隆子或中周期出参[8635]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCloneSubCycle(),"D3分析是否克隆子或中期权重(公共)-M3接收克隆子或中周期出参-克隆子或中周期不能为空",false);
      receptionServiceRes_2 = nbWeightTarget.implementSixReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&&  reqDto.getFatherMidSubCycleDataModel() !=null && reqDto.getFatherMidSubCycleDataModel().equals("FATHER_MID_SUB_SAME"))&&(omsEvaObjTargetCycleWeightSet_2 == null ||omsEvaObjTargetCycleWeightSet_4 == null )){
       //elseif(D3分析是否克隆子或中期权重(公共).父子中周期数据同体模型 等于 父子中同体 and (3-3-09-02查目标子周期权重.出参 值等于空  or 3-3-09-02查目标中期权重.出参 值等于空 ))  70088

//ModelCode: receptionService
        ImplementSixReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementSixReceivingFieldReqDto receptionServiceReq_2=new ImplementSixReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setCloneSubCycle(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1872954_1_70089
    }

    /*M3接收克隆子或中周期出参[8635]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getCloneSubCycle(),"D3分析是否克隆子或中期权重(公共)-M3接收克隆子或中周期出参-克隆子或中周期不能为空",false);
      receptionServiceRes_4 = nbWeightTarget.implementSixReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
else if((reqDto!= null&&  reqDto.getFatherMidSubCycleDataModel() !=null && reqDto.getFatherMidSubCycleDataModel().equals("FATHER_SUB_SAME")&&omsEvaObjTargetCycleWeightSet_2 == null )){
       //elseif((D3分析是否克隆子或中期权重(公共).父子中周期数据同体模型 等于 父子同体 and 3-3-09-02查目标子周期权重.出参 值等于空 ))  70090

//ModelCode: receptionService
        ImplementSixReceivingFieldRespDto receptionServiceRes_5 = null;
    ImplementSixReceivingFieldReqDto receptionServiceReq_3=new ImplementSixReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setCloneSubCycle(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1872954_1_70091
    }

    /*M3接收克隆子或中周期出参[8635]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getCloneSubCycle(),"D3分析是否克隆子或中期权重(公共)-M3接收克隆子或中周期出参-克隆子或中周期不能为空",false);
      receptionServiceRes_5 = nbWeightTarget.implementSixReceivingField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
    }
      }
else{
       //else  70086

//ModelCode: receptionService
        ImplementSixReceivingFieldRespDto receptionServiceRes_6 = null;
    ImplementSixReceivingFieldReqDto receptionServiceReq_4=new ImplementSixReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_4.setCloneSubCycle(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1872954_1_70087
    }

    /*M3接收克隆子或中周期出参[8635]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getCloneSubCycle(),"D3分析是否克隆子或中期权重(公共)-M3接收克隆子或中周期出参-克隆子或中周期不能为空",false);
      receptionServiceRes_6 = nbWeightTarget.implementSixReceivingField(receptionServiceReq_4);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
AnalysisIsCloneSubOrMidWeightComRespDto retData = new AnalysisIsCloneSubOrMidWeightComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setCloneSubCycle(receptionServiceRes_3.getCloneSubCycle());//SimpleFieldAssign//sourceId:1872956_1
    }




return retData;
  }
  //
}
